numpy-ts 1.0.0 → 1.2.0

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

@@ -19,7 +19,7 @@ export { sum, mean, prod, max, amax, min, amin, ptp, argmin, argmax, variance, v
 export { logical_and, logical_or, logical_not, logical_xor, isfinite, isinf, isnan, isnat, isneginf, isposinf, iscomplex, iscomplexobj, isreal, isrealobj, real_if_close, isfortran, isscalar, iterable, isdtype, promote_types, copysign, signbit, nextafter, spacing, greater, greater_equal, less, less_equal, equal, not_equal, isclose, allclose, } from './logic';
 export { sort, argsort, lexsort, partition, argpartition, sort_complex, nonzero, argwhere, flatnonzero, where, searchsorted, extract, count_nonzero, } from './sorting';
 export { bitwise_and, bitwise_or, bitwise_xor, bitwise_not, invert, left_shift, right_shift, packbits, unpackbits, bitwise_count, bitwise_invert, bitwise_left_shift, bitwise_right_shift, } from './bitwise';
-export { around, round_, round, ceil, fix, floor, rint, trunc } from './rounding';
+export { around, round, ceil, fix, floor, rint, trunc } from './rounding';
 export { unique, in1d, intersect1d, isin, setdiff1d, setxor1d, union1d, trim_zeros, unique_all, unique_counts, unique_inverse, unique_values, } from './sets';
 export { bincount, digitize, histogram, histogram2d, histogramdd, correlate, convolve, cov, corrcoef, histogram_bin_edges, trapezoid, } from './statistics';
 export { diff, ediff1d, gradient } from './gradient';
@@ -37,4 +37,97 @@ export { parseNpz, parseNpzSync, loadNpz, loadNpzSync, type NpzParseOptions, typ
 export { serializeNpz, serializeNpzSync, type NpzArraysInput, type NpzSerializeOptions, } from '../io/npz/serializer';
 export { parseTxt, genfromtxt, fromregex, type ParseTxtOptions } from '../io/txt/parser';
 export { serializeTxt, type SerializeTxtOptions } from '../io/txt/serializer';
+import * as randomOps from '../common/ops/random';
+import { ArrayStorage } from '../common/storage';
+import { NDArrayCore as NDArrayCoreClass } from '../common/ndarray-core';
+import { DType } from '../common/dtype';
+export declare const random: {
+    seed: typeof randomOps.seed;
+    get_state: typeof randomOps.get_state;
+    set_state: typeof randomOps.set_state;
+    get_bit_generator: typeof randomOps.get_bit_generator;
+    set_bit_generator: typeof randomOps.set_bit_generator;
+    default_rng: (seedValue?: number) => {
+        random: (size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+        integers: (low: number, high?: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+        standard_normal: (size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+        normal: (loc?: number, scale?: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+        uniform: (low?: number, high?: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+        choice: (a: number | (ArrayStorage | NDArrayCoreClass), size?: number | number[], replace?: boolean, p?: (ArrayStorage | NDArrayCoreClass) | number[]) => number | ArrayStorage | NDArrayCoreClass;
+        permutation: (x: number | (ArrayStorage | NDArrayCoreClass)) => ArrayStorage | NDArrayCoreClass;
+        shuffle: (x: ArrayStorage | NDArrayCoreClass) => void;
+        exponential: (scale?: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+        poisson: (lam?: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+        binomial: (n: number, p: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    };
+    Generator: typeof randomOps.Generator;
+    random: (size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    rand: (...shape: number[]) => number | ArrayStorage | NDArrayCoreClass;
+    randn: (...shape: number[]) => number | ArrayStorage | NDArrayCoreClass;
+    randint: (low: number, high?: number | null, size?: number | number[], dtype?: DType) => number | ArrayStorage | NDArrayCoreClass;
+    random_sample: (size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    ranf: (size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    sample: (size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    random_integers: (low: number, high?: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    bytes: typeof randomOps.bytes;
+    uniform: (low?: number, high?: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    normal: (loc?: number, scale?: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    standard_normal: (size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    exponential: (scale?: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    standard_exponential: (size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    gamma: (shape: number, scale?: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    standard_gamma: (shape: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    beta: (a: number, b: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    chisquare: (df: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    noncentral_chisquare: (df: number, nonc: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    f: (dfnum: number, dfden: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    noncentral_f: (dfnum: number, dfden: number, nonc: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    standard_cauchy: (size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    standard_t: (df: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    laplace: (loc?: number, scale?: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    logistic: (loc?: number, scale?: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    lognormal: (mean?: number, sigma?: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    gumbel: (loc?: number, scale?: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    pareto: (a: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    power: (a: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    rayleigh: (scale?: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    triangular: (left: number, mode: number, right: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    wald: (mean: number, scale: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    weibull: (a: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    poisson: (lam?: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    binomial: (n: number, p: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    geometric: (p: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    hypergeometric: (ngood: number, nbad: number, nsample: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    logseries: (p: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    negative_binomial: (n: number, p: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    zipf: (a: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    multinomial: (n: number, pvals: number[] | ArrayStorage, size?: number | number[]) => ArrayStorage | NDArrayCoreClass;
+    multivariate_normal: (mean: number[] | ArrayStorage, cov: number[][] | ArrayStorage, size?: number | number[], check_valid?: "warn" | "raise" | "ignore", tol?: number) => ArrayStorage | NDArrayCoreClass;
+    dirichlet: (alpha: number[] | ArrayStorage, size?: number | number[]) => ArrayStorage | NDArrayCoreClass;
+    vonmises: (mu: number, kappa: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    choice: (a: number | ArrayStorage, size?: number | number[], replace?: boolean, p?: ArrayStorage | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    permutation: (x: number | ArrayStorage) => ArrayStorage | NDArrayCoreClass;
+    shuffle: (x: NDArrayCoreClass | ArrayStorage) => void;
+};
+type ArrayInput = NDArrayCoreClass | ArrayStorage;
+export declare const fft: {
+    fft: (a: ArrayInput, n?: number, axis?: number, norm?: "backward" | "ortho" | "forward") => NDArrayCoreClass;
+    ifft: (a: ArrayInput, n?: number, axis?: number, norm?: "backward" | "ortho" | "forward") => NDArrayCoreClass;
+    fft2: (a: ArrayInput, s?: [number, number], axes?: [number, number], norm?: "backward" | "ortho" | "forward") => NDArrayCoreClass;
+    ifft2: (a: ArrayInput, s?: [number, number], axes?: [number, number], norm?: "backward" | "ortho" | "forward") => NDArrayCoreClass;
+    fftn: (a: ArrayInput, s?: number[], axes?: number[], norm?: "backward" | "ortho" | "forward") => NDArrayCoreClass;
+    ifftn: (a: ArrayInput, s?: number[], axes?: number[], norm?: "backward" | "ortho" | "forward") => NDArrayCoreClass;
+    rfft: (a: ArrayInput, n?: number, axis?: number, norm?: "backward" | "ortho" | "forward") => NDArrayCoreClass;
+    irfft: (a: ArrayInput, n?: number, axis?: number, norm?: "backward" | "ortho" | "forward") => NDArrayCoreClass;
+    rfft2: (a: ArrayInput, s?: [number, number], axes?: [number, number], norm?: "backward" | "ortho" | "forward") => NDArrayCoreClass;
+    irfft2: (a: ArrayInput, s?: [number, number], axes?: [number, number], norm?: "backward" | "ortho" | "forward") => NDArrayCoreClass;
+    rfftn: (a: ArrayInput, s?: number[], axes?: number[], norm?: "backward" | "ortho" | "forward") => NDArrayCoreClass;
+    irfftn: (a: ArrayInput, s?: number[], axes?: number[], norm?: "backward" | "ortho" | "forward") => NDArrayCoreClass;
+    hfft: (a: ArrayInput, n?: number, axis?: number, norm?: "backward" | "ortho" | "forward") => NDArrayCoreClass;
+    ihfft: (a: ArrayInput, n?: number, axis?: number, norm?: "backward" | "ortho" | "forward") => NDArrayCoreClass;
+    fftfreq: (n: number, d?: number) => NDArrayCoreClass;
+    rfftfreq: (n: number, d?: number) => NDArrayCoreClass;
+    fftshift: (a: ArrayInput, axes?: number | number[]) => NDArrayCoreClass;
+    ifftshift: (a: ArrayInput, axes?: number | number[]) => NDArrayCoreClass;
+};
 //# sourceMappingURL=index.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/rounding.d.ts

@@ -7,8 +7,6 @@
 import { NDArrayCore } from './types';
 /** Round to given decimals */
 export declare function around(a: NDArrayCore, decimals?: number): NDArrayCore;
-/** Alias for around */
-export declare const round_: typeof around;
 /** Round (same as around) */
 export declare function round(a: NDArrayCore, decimals?: number): NDArrayCore;
 /** Ceiling */

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, 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

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

@@ -67,12 +67,6 @@ export declare class NDArray extends NDArrayCore {
      * @returns Array with specified dtype
      */
     astype(dtype: DType, copy?: boolean): NDArray;
-    /**
-     * Slice the array using NumPy-style string syntax
-     * @param sliceStrs - Slice specifications, one per dimension
-     * @returns Sliced view of the array
-     */
-    slice(...sliceStrs: string[]): NDArray;
     /**
      * Get a single row (convenience method)
      * @param i - Row index
@@ -241,7 +235,7 @@ export declare class NDArray extends NDArrayCore {
      * Sum of diagonal elements (trace)
      * @returns Sum of diagonal elements
      */
-    trace(): number | bigint | Complex;
+    trace(): NDArray | number | bigint | Complex;
     /**
      * Inner product (contracts over last axes of both arrays)
      * @param other - Array to compute inner product with
@@ -640,23 +634,23 @@ export declare class NDArray extends NDArrayCore {
     /**
      * Sum array elements over a given axis
      */
-    sum(axis?: number, keepdims?: boolean): NDArray | number | bigint | Complex;
+    sum(axis?: number | number[], keepdims?: boolean): NDArray | number | bigint | Complex;
     /**
      * Compute the arithmetic mean along the specified axis
      */
-    mean(axis?: number, keepdims?: boolean): NDArray | number | Complex;
+    mean(axis?: number | number[], keepdims?: boolean): NDArray | number | Complex;
     /**
      * Product of array elements over a given axis
      */
-    prod(axis?: number, keepdims?: boolean): NDArray | number | bigint | Complex;
+    prod(axis?: number | number[], keepdims?: boolean): NDArray | number | bigint | Complex;
     /**
      * Return the maximum along a given axis
      */
-    max(axis?: number, keepdims?: boolean): NDArray | number | Complex;
+    max(axis?: number | number[], keepdims?: boolean): NDArray | number | Complex;
     /**
      * Return the minimum along a given axis
      */
-    min(axis?: number, keepdims?: boolean): NDArray | number | Complex;
+    min(axis?: number | number[], keepdims?: boolean): NDArray | number | Complex;
     /**
      * Peak to peak (maximum - minimum) value along a given axis
      */
@@ -664,23 +658,23 @@ export declare class NDArray extends NDArrayCore {
     /**
      * Return the sum of array elements, treating NaNs as zero
      */
-    nansum(axis?: number, keepdims?: boolean): NDArray | number | Complex;
+    nansum(axis?: number | number[], keepdims?: boolean): NDArray | number | Complex;
     /**
      * Return the product of array elements, treating NaNs as ones
      */
-    nanprod(axis?: number, keepdims?: boolean): NDArray | number | Complex;
+    nanprod(axis?: number | number[], keepdims?: boolean): NDArray | number | Complex;
     /**
      * Compute the arithmetic mean, ignoring NaNs
      */
-    nanmean(axis?: number, keepdims?: boolean): NDArray | number | Complex;
+    nanmean(axis?: number | number[], keepdims?: boolean): NDArray | number | Complex;
     /**
      * Return minimum of an array, ignoring NaNs
      */
-    nanmin(axis?: number, keepdims?: boolean): NDArray | number | Complex;
+    nanmin(axis?: number | number[], keepdims?: boolean): NDArray | number | Complex;
     /**
      * Return maximum of an array, ignoring NaNs
      */
-    nanmax(axis?: number, keepdims?: boolean): NDArray | number | Complex;
+    nanmax(axis?: number | number[], keepdims?: boolean): NDArray | number | Complex;
     /**
      * Indices of the minimum values along an axis
      */
@@ -717,26 +711,26 @@ export declare class NDArray extends NDArrayCore {
      * @param ddof - Delta degrees of freedom (default: 0)
      * @param keepdims - If true, reduced axes are left as dimensions with size 1
      */
-    nanvar(axis?: number, ddof?: number, keepdims?: boolean): NDArray | number;
+    nanvar(axis?: number | number[], ddof?: number, keepdims?: boolean): NDArray | number;
     /**
      * Compute the standard deviation, ignoring NaNs
      * @param axis - Axis along which to compute std
      * @param ddof - Delta degrees of freedom (default: 0)
      * @param keepdims - If true, reduced axes are left as dimensions with size 1
      */
-    nanstd(axis?: number, ddof?: number, keepdims?: boolean): NDArray | number;
+    nanstd(axis?: number | number[], ddof?: number, keepdims?: boolean): NDArray | number;
     /**
      * Test whether all array elements along a given axis evaluate to True
      */
-    all(axis?: number, keepdims?: boolean): NDArray | boolean;
+    all(axis?: number | number[], keepdims?: boolean): NDArray | boolean;
     /**
      * Test whether any array elements along a given axis evaluate to True
      */
-    any(axis?: number, keepdims?: boolean): NDArray | boolean;
+    any(axis?: number | number[], keepdims?: boolean): NDArray | boolean;
     /**
      * Compute the median along the specified axis
      */
-    median(axis?: number, keepdims?: boolean): NDArray | number;
+    median(axis?: number | number[], keepdims?: boolean): NDArray | number;
     /**
      * Compute the median, ignoring NaNs
      */

package/dist/types/index.d.ts

@@ -22,6 +22,7 @@
 export { Complex, type ComplexInput } from './common/complex';
 export { NDArray } from './full';
 export { NDArrayCore } from './common/ndarray-core';
+export { hasFloat16 } from './common/dtype';
 export { zeros, ones, empty, full, array, arange, linspace, logspace, geomspace, eye, identity, asarray, zeros_like, ones_like, empty_like, full_like, copy, asanyarray, asarray_chkfinite, ascontiguousarray, asfortranarray, require, diag, diagflat, frombuffer, fromfile, fromfunction, fromiter, fromstring, meshgrid, tri, tril, triu, vander, } from './full';
 export { add, subtract, multiply, divide, true_divide, floor_divide, mod, sqrt, power, exp, exp2, expm1, log, log2, log10, log1p, logaddexp, logaddexp2, absolute, negative, sign, positive, reciprocal, cbrt, fabs, divmod, square, remainder, heaviside, float_power, fmod, frexp, gcd, lcm, ldexp, modf, clip, maximum, minimum, fmax, fmin, nan_to_num, interp, unwrap, sinc, i0, } from './full';
 export { power as pow, absolute as abs } from './full';
@@ -36,7 +37,7 @@ export { logical_and, logical_or, logical_not, logical_xor, isfinite, isinf, isn
 export { sort, argsort, lexsort, partition, argpartition, sort_complex, nonzero, argwhere, flatnonzero, where, searchsorted, extract, count_nonzero, } from './full';
 export { bitwise_and, bitwise_or, bitwise_xor, bitwise_not, invert, left_shift, right_shift, packbits, unpackbits, bitwise_count, } from './full';
 export { bitwise_not as bitwise_invert, left_shift as bitwise_left_shift, right_shift as bitwise_right_shift, } from './full';
-export { around, round_, ceil, fix, floor, rint, trunc } from './full';
+export { around, ceil, fix, floor, rint, trunc } from './full';
 export { around as round } from './full';
 export { unique, in1d, intersect1d, isin, setdiff1d, setxor1d, union1d, trim_zeros, unique_all, unique_counts, unique_inverse, unique_values, } from './full';
 export { bincount, digitize, histogram, histogram2d, histogramdd, correlate, convolve, cov, corrcoef, histogram_bin_edges, trapezoid, } from './full';
@@ -53,6 +54,7 @@ export type { NpzParseOptions } from './io/npz/parser';
 export type { NpzSerializeOptions } from './io/npz/serializer';
 export type { ParseTxtOptions } from './io/txt/parser';
 export type { SerializeTxtOptions } from './io/txt/serializer';
+export { wasmConfig } from './common/wasm/config';
 export { serializeNpy } from './io/npy/serializer';
 export { serializeNpz, serializeNpzSync } from './io/npz/serializer';
 export { serializeTxt } from './io/txt/serializer';
@@ -77,6 +79,7 @@ export declare function loadNpzSync(buffer: ArrayBuffer | Uint8Array, options?:
 export declare function parseTxt(text: string, options?: ParseTxtOptionsType): NDArrayClass;
 export declare function genfromtxt(text: string, options?: ParseTxtOptionsType): NDArrayClass;
 export declare function fromregex(text: string, regexp: RegExp | string, dtype?: DTypeIO): NDArrayClass;
+export { type LoadOptions, type SaveNpzOptions, type LoadTxtOptions, type SaveTxtOptions, loadNpy, loadNpySync, saveNpy, saveNpySync, loadNpzFile, loadNpzFileSync, saveNpz as saveNpzFile, saveNpzSync as saveNpzFileSync, savez, savez_compressed, load, loadSync, save, saveSync, loadtxt, loadtxtSync, savetxt, savetxtSync, genfromtxt as genfromtxtFile, genfromtxtSync as genfromtxtFileSync, fromregex as fromregexFile, fromregexSync as fromregexFileSync, } from './io/file-ops';
 import * as randomOps from './common/ops/random';
 import { ArrayStorage } from './common/storage';
 import { NDArray as NDArrayClass } from './full';
@@ -87,7 +90,19 @@ export declare const random: {
     set_state: typeof randomOps.set_state;
     get_bit_generator: typeof randomOps.get_bit_generator;
     set_bit_generator: typeof randomOps.set_bit_generator;
-    default_rng: typeof randomOps.default_rng;
+    default_rng: (seedValue?: number) => {
+        random: (size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+        integers: (low: number, high?: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+        standard_normal: (size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+        normal: (loc?: number, scale?: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+        uniform: (low?: number, high?: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+        choice: (a: number | (ArrayStorage | NDArrayCore | NDArrayClass), size?: number | number[], replace?: boolean, p?: (ArrayStorage | NDArrayCore | NDArrayClass) | number[]) => number | ArrayStorage | NDArrayClass;
+        permutation: (x: number | (ArrayStorage | NDArrayCore | NDArrayClass)) => ArrayStorage | NDArrayClass;
+        shuffle: (x: ArrayStorage | NDArrayCore | NDArrayClass) => void;
+        exponential: (scale?: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+        poisson: (lam?: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+        binomial: (n: number, p: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    };
     Generator: typeof randomOps.Generator;
     random: (size?: number | number[]) => number | ArrayStorage | NDArrayClass;
     rand: (...shape: number[]) => number | ArrayStorage | NDArrayClass;
@@ -135,7 +150,7 @@ export declare const random: {
     vonmises: (mu: number, kappa: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
     choice: (a: number | ArrayStorage, size?: number | number[], replace?: boolean, p?: ArrayStorage | number[]) => number | ArrayStorage | NDArrayClass;
     permutation: (x: number | ArrayStorage) => ArrayStorage | NDArrayClass;
-    shuffle: typeof randomOps.shuffle;
+    shuffle: (x: NDArrayClass | NDArrayCore | ArrayStorage) => void;
 };
 import { NDArrayCore } from './common/ndarray-core';
 type ArrayInput = NDArrayClass | NDArrayCore | ArrayStorage;