numpy-ts 0.11.0 → 0.12.0

package/dist/types/index.d.ts

@@ -4,22 +4,22 @@
  * @module numpy-ts
  */
 export { Complex, type ComplexInput } from './core/complex';
-export { NDArray, zeros, ones, array, arange, linspace, logspace, geomspace, eye, empty, full, identity, asarray, copy, zeros_like, ones_like, empty_like, full_like, asanyarray, ascontiguousarray, asfortranarray, diag, diagflat, frombuffer, fromfile, fromfunction, fromiter, fromstring, meshgrid, tri, tril, triu, vander, sqrt, power, pow, // alias for power
+export { NDArray, zeros, ones, array, arange, linspace, logspace, geomspace, eye, empty, full, identity, asarray, copy, zeros_like, ones_like, empty_like, full_like, asanyarray, asarray_chkfinite, ascontiguousarray, asfortranarray, require, diag, diagflat, frombuffer, fromfile, fromfunction, fromiter, fromstring, meshgrid, tri, tril, triu, vander, sqrt, power, pow, // alias for power
 exp, exp2, expm1, log, log2, log10, log1p, logaddexp, logaddexp2, absolute, abs, // alias for absolute
 negative, sign, mod, divide, true_divide, // alias for divide
-floor_divide, positive, reciprocal, cbrt, fabs, divmod, square, remainder, heaviside, float_power, fmod, frexp, gcd, lcm, ldexp, modf, dot, trace, diagonal, kron, transpose, inner, outer, tensordot, einsum, linalg, sin, cos, tan, arcsin, asin, // alias for arcsin
+floor_divide, 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, dot, trace, diagonal, kron, transpose, inner, outer, tensordot, einsum, vdot, vecdot, matrix_transpose, permute_dims, matvec, vecmat, linalg, sin, cos, tan, arcsin, asin, // alias for arcsin
 arccos, acos, // alias for arccos
 arctan, atan, // alias for arctan
 arctan2, atan2, // alias for arctan2
 hypot, degrees, radians, deg2rad, rad2deg, sinh, cosh, tanh, arcsinh, asinh, // alias for arcsinh
 arccosh, acosh, // alias for arccosh
 arctanh, atanh, // alias for arctanh
-swapaxes, moveaxis, concatenate, stack, vstack, hstack, dstack, split, array_split, vsplit, hsplit, tile, repeat, ravel, reshape, squeeze, expand_dims, flip, fliplr, flipud, rot90, roll, rollaxis, atleast_1d, atleast_2d, atleast_3d, dsplit, column_stack, row_stack, resize, append, delete_ as delete, insert, pad, broadcast_to, broadcast_arrays, broadcast_shapes, take, put, iindex, bindex, copyto, choose, array_equal, array_equiv, take_along_axis, put_along_axis, putmask, compress, select, place, fill_diagonal, diag_indices, diag_indices_from, tril_indices, tril_indices_from, triu_indices, triu_indices_from, mask_indices, indices, ix_, ravel_multi_index, unravel_index, cumsum, cumulative_sum, // alias for cumsum
+swapaxes, moveaxis, concatenate, stack, vstack, hstack, dstack, concat, unstack, block, split, array_split, vsplit, hsplit, tile, repeat, ravel, flatten, fill, item, tolist, tobytes, byteswap, view, tofile, reshape, squeeze, expand_dims, flip, fliplr, flipud, rot90, roll, rollaxis, atleast_1d, atleast_2d, atleast_3d, dsplit, column_stack, row_stack, resize, append, delete_ as delete, insert, pad, broadcast_to, broadcast_arrays, broadcast_shapes, take, put, iindex, bindex, copyto, choose, array_equal, array_equiv, take_along_axis, put_along_axis, putmask, compress, select, place, fill_diagonal, diag_indices, diag_indices_from, tril_indices, tril_indices_from, triu_indices, triu_indices_from, mask_indices, indices, ix_, ravel_multi_index, unravel_index, cumsum, cumulative_sum, // alias for cumsum
 cumprod, cumulative_prod, // alias for cumprod
 max, amax, // alias for max
 min, amin, // alias for min
-ptp, median, percentile, quantile, average, nansum, nanprod, nanmean, nanvar, nanstd, nanmin, nanmax, nanargmin, nanargmax, nancumsum, nancumprod, nanmedian, bitwise_and, bitwise_or, bitwise_xor, bitwise_not, invert, left_shift, right_shift, packbits, unpackbits, logical_and, logical_or, logical_not, logical_xor, isfinite, isinf, isnan, isnat, iscomplex, iscomplexobj, isreal, isrealobj, real, imag, conj, conjugate, angle, isneginf, isposinf, isfortran, real_if_close, isscalar, iterable, isdtype, promote_types, copysign, signbit, nextafter, spacing, sort, argsort, lexsort, partition, argpartition, sort_complex, nonzero, argwhere, flatnonzero, where, searchsorted, extract, count_nonzero, around, round_, // alias for around
-ceil, fix, floor, rint, round, trunc, unique, in1d, intersect1d, isin, setdiff1d, setxor1d, union1d, diff, ediff1d, gradient, cross, bincount, digitize, histogram, histogram2d, histogramdd, correlate, convolve, cov, corrcoef, } from './core/ndarray';
+ptp, median, percentile, quantile, average, nansum, nanprod, nanmean, nanvar, nanstd, nanmin, nanmax, nanargmin, nanargmax, nancumsum, nancumprod, nanmedian, nanquantile, nanpercentile, 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, logical_and, logical_or, logical_not, logical_xor, isfinite, isinf, isnan, isnat, iscomplex, iscomplexobj, isreal, isrealobj, real, imag, conj, conjugate, angle, isneginf, isposinf, isfortran, real_if_close, isscalar, iterable, isdtype, promote_types, copysign, signbit, nextafter, spacing, sort, argsort, lexsort, partition, argpartition, sort_complex, nonzero, argwhere, flatnonzero, where, searchsorted, extract, count_nonzero, around, round_, // alias for around
+ceil, fix, floor, rint, round, trunc, unique, in1d, intersect1d, isin, setdiff1d, setxor1d, union1d, trim_zeros, unique_all, unique_counts, unique_inverse, unique_values, diff, ediff1d, gradient, cross, bincount, digitize, histogram, histogram2d, histogramdd, correlate, convolve, cov, corrcoef, histogram_bin_edges, trapezoid, apply_along_axis, apply_over_axes, may_share_memory, shares_memory, ndim, shape, size, geterr, seterr, can_cast, common_type, result_type, min_scalar_type, issubdtype, typename, mintypecode, poly, polyadd, polyder, polydiv, polyfit, polyint, polymul, polysub, polyval, roots, } from './core/ndarray';
 export { parseNpy, serializeNpy, parseNpyHeader, parseNpyData, UnsupportedDTypeError, InvalidNpyError, SUPPORTED_DTYPES, DTYPE_TO_DESCR, type NpyHeader, type NpyMetadata, type NpyVersion, parseNpz, parseNpzSync, loadNpz, loadNpzSync, serializeNpz, serializeNpzSync, type NpzParseOptions, type NpzParseResult, type NpzSerializeOptions, } from './io';
 import * as randomOps from './ops/random';
 import { ArrayStorage } from './core/storage';

package/dist/types/ops/advanced.d.ts

@@ -112,4 +112,69 @@ export declare function unravel_index(indices: ArrayStorage | number, shape: num
  * @param wrap - Whether to wrap for tall matrices
  */
 export declare function fill_diagonal(a: ArrayStorage, val: ArrayStorage | number, wrap?: boolean): void;
+/**
+ * Apply a function along a given axis.
+ *
+ * @param arr - Input array storage
+ * @param axis - Axis along which to apply the function
+ * @param func1d - Function that takes a 1D array and returns a 1D array or scalar
+ * @returns Result array
+ */
+export declare function apply_along_axis(arr: ArrayStorage, axis: number, func1d: (slice: ArrayStorage) => ArrayStorage | number): ArrayStorage;
+/**
+ * Apply a function over multiple axes.
+ *
+ * @param arr - Input array storage
+ * @param func - Function that operates on an array
+ * @param axes - Axes over which to apply the function
+ * @returns Result array
+ */
+export declare function apply_over_axes(arr: ArrayStorage, func: (a: ArrayStorage, axis: number) => ArrayStorage, axes: number[]): ArrayStorage;
+/**
+ * Check if two arrays may share memory.
+ *
+ * In JavaScript, we can't directly check memory sharing like in Python.
+ * This is a conservative implementation that returns true if they share
+ * the same underlying buffer.
+ *
+ * @param a - First array storage
+ * @param b - Second array storage
+ * @returns True if arrays may share memory
+ */
+export declare function may_share_memory(a: ArrayStorage, b: ArrayStorage): boolean;
+/**
+ * Check if two arrays share memory.
+ *
+ * This is the same as may_share_memory in our implementation since
+ * JavaScript doesn't have the same memory model as Python/NumPy.
+ *
+ * @param a - First array storage
+ * @param b - Second array storage
+ * @returns True if arrays share memory
+ */
+export declare function shares_memory(a: ArrayStorage, b: ArrayStorage): boolean;
+type ErrorMode = 'ignore' | 'warn' | 'raise' | 'call' | 'print' | 'log';
+export interface FloatErrorState {
+    divide: ErrorMode;
+    over: ErrorMode;
+    under: ErrorMode;
+    invalid: ErrorMode;
+}
+/**
+ * Get the current floating-point error handling.
+ *
+ * @returns Current error handling settings
+ */
+export declare function geterr(): FloatErrorState;
+/**
+ * Set how floating-point errors are handled.
+ *
+ * @param all - Set all error modes at once (optional)
+ * @param divide - Treatment for division by zero
+ * @param over - Treatment for floating-point overflow
+ * @param under - Treatment for floating-point underflow
+ * @param invalid - Treatment for invalid floating-point operation
+ * @returns Previous error handling settings
+ */
+export declare function seterr(all?: ErrorMode, divide?: ErrorMode, over?: ErrorMode, under?: ErrorMode, invalid?: ErrorMode): FloatErrorState;
 //# sourceMappingURL=advanced.d.ts.map

package/dist/types/ops/arithmetic.d.ts

@@ -212,4 +212,103 @@ export declare function ldexp(x1: ArrayStorage, x2: ArrayStorage | number): Arra
  * @returns Tuple of [fractional, integral] arrays
  */
 export declare function modf(x: ArrayStorage): [ArrayStorage, ArrayStorage];
+/**
+ * Clip (limit) the values in an array
+ * Given an interval, values outside the interval are clipped to the interval edges.
+ *
+ * @param a - Input array storage
+ * @param a_min - Minimum value (null to not clip minimum)
+ * @param a_max - Maximum value (null to not clip maximum)
+ * @returns Clipped array storage
+ */
+export declare function clip(a: ArrayStorage, a_min: number | ArrayStorage | null, a_max: number | ArrayStorage | null): ArrayStorage;
+/**
+ * Element-wise maximum of array elements
+ *
+ * @param x1 - First array storage
+ * @param x2 - Second array storage or scalar
+ * @returns Element-wise maximum
+ */
+export declare function maximum(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
+/**
+ * Element-wise minimum of array elements
+ *
+ * @param x1 - First array storage
+ * @param x2 - Second array storage or scalar
+ * @returns Element-wise minimum
+ */
+export declare function minimum(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
+/**
+ * Element-wise maximum of array elements, ignoring NaNs
+ *
+ * @param x1 - First array storage
+ * @param x2 - Second array storage or scalar
+ * @returns Element-wise maximum, NaN-aware
+ */
+export declare function fmax(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
+/**
+ * Element-wise minimum of array elements, ignoring NaNs
+ *
+ * @param x1 - First array storage
+ * @param x2 - Second array storage or scalar
+ * @returns Element-wise minimum, NaN-aware
+ */
+export declare function fmin(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
+/**
+ * Replace NaN with zero and Inf with large finite numbers
+ *
+ * @param x - Input array storage
+ * @param nan - Value to replace NaN (default: 0.0)
+ * @param posinf - Value to replace positive infinity (default: largest finite)
+ * @param neginf - Value to replace negative infinity (default: most negative finite)
+ * @returns Array with replacements
+ */
+export declare function nan_to_num(x: ArrayStorage, nan?: number, posinf?: number, neginf?: number): ArrayStorage;
+/**
+ * One-dimensional linear interpolation
+ *
+ * Returns the one-dimensional piecewise linear interpolant to a function
+ * with given discrete data points (xp, fp), evaluated at x.
+ *
+ * @param x - The x-coordinates at which to evaluate the interpolated values
+ * @param xp - The x-coordinates of the data points (must be increasing)
+ * @param fp - The y-coordinates of the data points
+ * @param left - Value for x < xp[0] (default: fp[0])
+ * @param right - Value for x > xp[-1] (default: fp[-1])
+ * @returns Interpolated values
+ */
+export declare function interp(x: ArrayStorage, xp: ArrayStorage, fp: ArrayStorage, left?: number, right?: number): ArrayStorage;
+/**
+ * Unwrap by changing deltas between values to 2*pi complement
+ *
+ * Unwrap radian phase p by changing absolute jumps greater than
+ * discont to their 2*pi complement along the given axis.
+ *
+ * @param p - Input array of phase angles in radians
+ * @param discont - Maximum discontinuity between values (default: pi)
+ * @param axis - Axis along which to unwrap (default: -1, last axis)
+ * @param period - Size of the range over which the input wraps (default: 2*pi)
+ * @returns Unwrapped array
+ */
+export declare function unwrap(p: ArrayStorage, discont?: number, axis?: number, period?: number): ArrayStorage;
+/**
+ * Return the normalized sinc function
+ *
+ * sinc(x) = sin(pi*x) / (pi*x)
+ *
+ * The sinc function is 1 at x = 0, and sin(pi*x)/(pi*x) otherwise.
+ *
+ * @param x - Input array
+ * @returns Array of sinc values
+ */
+export declare function sinc(x: ArrayStorage): ArrayStorage;
+/**
+ * Modified Bessel function of the first kind, order 0
+ *
+ * Uses polynomial approximation.
+ *
+ * @param x - Input array
+ * @returns Array of I0 values
+ */
+export declare function i0(x: ArrayStorage): ArrayStorage;
 //# sourceMappingURL=arithmetic.d.ts.map

package/dist/types/ops/bitwise.d.ts

@@ -88,4 +88,34 @@ export declare function packbits(a: ArrayStorage, axis?: number, bitorder?: 'big
  * @returns Unpacked uint8 array of 0s and 1s
  */
 export declare function unpackbits(a: ArrayStorage, axis?: number, count?: number, bitorder?: 'big' | 'little'): ArrayStorage;
+/**
+ * Count the number of 1-bits in each element (population count).
+ *
+ * @param x - Input array (must be integer type)
+ * @returns Array with population count for each element
+ */
+export declare function bitwise_count(x: ArrayStorage): ArrayStorage;
+/**
+ * Bitwise invert (alias for bitwise_not)
+ *
+ * @param x - Input array (must be integer type)
+ * @returns Result storage with bitwise NOT values
+ */
+export declare function bitwise_invert(x: ArrayStorage): ArrayStorage;
+/**
+ * Bitwise left shift (alias for left_shift)
+ *
+ * @param x1 - Input array (must be integer type)
+ * @param x2 - Shift amount (array or scalar)
+ * @returns Result storage with left-shifted values
+ */
+export declare function bitwise_left_shift(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
+/**
+ * Bitwise right shift (alias for right_shift)
+ *
+ * @param x1 - Input array (must be integer type)
+ * @param x2 - Shift amount (array or scalar)
+ * @returns Result storage with right-shifted values
+ */
+export declare function bitwise_right_shift(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
 //# sourceMappingURL=bitwise.d.ts.map

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

@@ -364,4 +364,128 @@ export declare function eigvals(a: ArrayStorage): ArrayStorage;
  * @returns Array of eigenvalues (sorted ascending)
  */
 export declare function eigvalsh(a: ArrayStorage, UPLO?: 'L' | 'U'): ArrayStorage;
+/**
+ * Return the dot product of two vectors (flattened).
+ *
+ * Unlike dot(), vdot flattens both inputs before computing the dot product.
+ * For complex numbers, vdot uses the complex conjugate of the first argument.
+ *
+ * @param a - First input array (will be flattened)
+ * @param b - Second input array (will be flattened)
+ * @returns Scalar dot product
+ */
+export declare function vdot(a: ArrayStorage, b: ArrayStorage): number | bigint | Complex;
+/**
+ * Vector dot product along the last axis.
+ *
+ * Computes the dot product of vectors along the last axis of both inputs.
+ * The last dimensions of a and b must match.
+ *
+ * @param a - First input array
+ * @param b - Second input array
+ * @param axis - Axis along which to compute (default: -1, meaning last axis)
+ * @returns Result with last dimension removed
+ */
+export declare function vecdot(a: ArrayStorage, b: ArrayStorage, axis?: number): ArrayStorage | number | bigint | Complex;
+/**
+ * Transpose the last two axes of an array.
+ *
+ * Equivalent to swapaxes(a, -2, -1) or transpose with axes that swap the last two.
+ * For a 2D array, this is the same as transpose.
+ *
+ * @param a - Input array with at least 2 dimensions
+ * @returns Array with last two axes transposed
+ */
+export declare function matrix_transpose(a: ArrayStorage): ArrayStorage;
+/**
+ * Permute the dimensions of an array.
+ *
+ * This is an alias for transpose to match the Array API standard.
+ *
+ * @param a - Input array
+ * @param axes - Permutation of axes. If not specified, reverses the axes.
+ * @returns Transposed array
+ */
+export declare function permute_dims(a: ArrayStorage, axes?: number[]): ArrayStorage;
+/**
+ * Matrix-vector multiplication.
+ *
+ * Computes the matrix-vector product over the last two axes of x1 and
+ * the last axis of x2.
+ *
+ * @param x1 - First input array (matrix) with shape (..., M, N)
+ * @param x2 - Second input array (vector) with shape (..., N)
+ * @returns Result with shape (..., M)
+ */
+export declare function matvec(x1: ArrayStorage, x2: ArrayStorage): ArrayStorage;
+/**
+ * Vector-matrix multiplication.
+ *
+ * Computes the vector-matrix product over the last axis of x1 and
+ * the second-to-last axis of x2.
+ *
+ * @param x1 - First input array (vector) with shape (..., M)
+ * @param x2 - Second input array (matrix) with shape (..., M, N)
+ * @returns Result with shape (..., N)
+ */
+export declare function vecmat(x1: ArrayStorage, x2: ArrayStorage): ArrayStorage;
+/**
+ * Compute sign and (natural) logarithm of the determinant.
+ *
+ * Returns (sign, logabsdet) where sign is the sign of the determinant
+ * and logabsdet is the natural log of the absolute value of the determinant.
+ *
+ * This is useful for computing determinants of large matrices where the
+ * determinant itself might overflow or underflow.
+ *
+ * @param a - Square matrix
+ * @returns { sign, logabsdet }
+ */
+export declare function slogdet(a: ArrayStorage): {
+    sign: number;
+    logabsdet: number;
+};
+/**
+ * Compute singular values of a matrix.
+ *
+ * This is equivalent to svd(a, compute_uv=False) but more efficient
+ * as it doesn't compute the U and V matrices.
+ *
+ * @param a - Input matrix (m x n)
+ * @returns 1D array of singular values in descending order
+ */
+export declare function svdvals(a: ArrayStorage): ArrayStorage;
+/**
+ * Compute the dot product of two or more arrays in a single function call.
+ *
+ * Optimizes the order of multiplications to minimize computation.
+ * For example, for three arrays A, B, C with shapes (10, 100), (100, 5), (5, 50),
+ * it's more efficient to compute (A @ B) @ C than A @ (B @ C).
+ *
+ * @param arrays - List of arrays to multiply
+ * @returns Result of multiplying all arrays
+ */
+export declare function multi_dot(arrays: ArrayStorage[]): ArrayStorage;
+/**
+ * Compute the 'inverse' of an N-dimensional array.
+ *
+ * The inverse is defined such that tensordot(tensorinv(a), a, ind) == I
+ * where I is the identity operator.
+ *
+ * @param a - Input array to invert
+ * @param ind - Number of first indices that are involved in the inverse sum (default: 2)
+ * @returns Tensor inverse
+ */
+export declare function tensorinv(a: ArrayStorage, ind?: number): ArrayStorage;
+/**
+ * Solve the tensor equation a x = b for x.
+ *
+ * This is equivalent to solve after reshaping a and b appropriately.
+ *
+ * @param a - Coefficient tensor
+ * @param b - Target tensor
+ * @param axes - Axes of a to be summed over in the contraction (default based on b.ndim)
+ * @returns Solution tensor x
+ */
+export declare function tensorsolve(a: ArrayStorage, b: ArrayStorage, axes?: number[] | null): ArrayStorage;
 //# sourceMappingURL=linalg.d.ts.map

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

@@ -142,4 +142,12 @@ export declare function nancumprod(storage: ArrayStorage, axis?: number): ArrayS
  * Compute median ignoring NaN values
  */
 export declare function nanmedian(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
+/**
+ * Compute the q-th quantile of data along specified axis, ignoring NaNs
+ */
+export declare function nanquantile(storage: ArrayStorage, q: number, axis?: number, keepdims?: boolean): ArrayStorage | number;
+/**
+ * Compute the q-th percentile of data along specified axis, ignoring NaNs
+ */
+export declare function nanpercentile(storage: ArrayStorage, q: number, axis?: number, keepdims?: boolean): ArrayStorage | number;
 //# sourceMappingURL=reduction.d.ts.map

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

@@ -35,4 +35,53 @@ export declare function setxor1d(ar1: ArrayStorage, ar2: ArrayStorage): ArraySto
  * Find the union of two arrays
  */
 export declare function union1d(ar1: ArrayStorage, ar2: ArrayStorage): ArrayStorage;
+/**
+ * Trim leading and/or trailing zeros from a 1-D array.
+ *
+ * @param filt - Input 1-D array
+ * @param trim - 'fb' to trim front and back, 'f' for front only, 'b' for back only (default: 'fb')
+ * @returns Trimmed array
+ */
+export declare function trim_zeros(filt: ArrayStorage, trim?: 'f' | 'b' | 'fb'): ArrayStorage;
+/**
+ * Find the unique elements of an array, returning all optional outputs.
+ *
+ * @param x - Input array (flattened for uniqueness)
+ * @returns Object with values, indices, inverse_indices, and counts
+ */
+export declare function unique_all(x: ArrayStorage): {
+    values: ArrayStorage;
+    indices: ArrayStorage;
+    inverse_indices: ArrayStorage;
+    counts: ArrayStorage;
+};
+/**
+ * Find the unique elements of an array and their counts.
+ *
+ * @param x - Input array (flattened for uniqueness)
+ * @returns Object with values and counts
+ */
+export declare function unique_counts(x: ArrayStorage): {
+    values: ArrayStorage;
+    counts: ArrayStorage;
+};
+/**
+ * Find the unique elements of an array and their inverse indices.
+ *
+ * @param x - Input array (flattened for uniqueness)
+ * @returns Object with values and inverse_indices
+ */
+export declare function unique_inverse(x: ArrayStorage): {
+    values: ArrayStorage;
+    inverse_indices: ArrayStorage;
+};
+/**
+ * Find the unique elements of an array (values only).
+ *
+ * This is equivalent to unique(x) but with a clearer name for the Array API.
+ *
+ * @param x - Input array (flattened for uniqueness)
+ * @returns Array of unique values, sorted
+ */
+export declare function unique_values(x: ArrayStorage): ArrayStorage;
 //# sourceMappingURL=sets.d.ts.map

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

@@ -141,4 +141,17 @@ export declare function atleast2d(storages: ArrayStorage[]): ArrayStorage[];
  * Convert arrays to at least 3D
  */
 export declare function atleast3d(storages: ArrayStorage[]): ArrayStorage[];
+/**
+ * Alias for concatenate
+ */
+export declare function concat(storages: ArrayStorage[], axis?: number): ArrayStorage;
+/**
+ * Split an array into a sequence of sub-arrays along an axis (inverse of stack)
+ */
+export declare function unstack(storage: ArrayStorage, axis?: number): ArrayStorage[];
+/**
+ * Assemble an nd-array from nested lists of blocks
+ * For a simple list [a, b] of nD arrays, concatenates along the last axis (like np.block)
+ */
+export declare function block(storages: ArrayStorage[], _depth?: number): ArrayStorage;
 //# sourceMappingURL=shape.d.ts.map

package/dist/types/ops/statistics.d.ts

@@ -105,4 +105,26 @@ export declare function cov(m: ArrayStorage, y?: ArrayStorage, rowvar?: boolean,
  * @returns Correlation coefficient matrix
  */
 export declare function corrcoef(x: ArrayStorage, y?: ArrayStorage, rowvar?: boolean): ArrayStorage;
+/**
+ * Compute the edges of the bins for histogram.
+ *
+ * This function computes the bin edges without computing the histogram itself.
+ *
+ * @param a - Input data (flattened if not 1D)
+ * @param bins - Number of bins (default: 10) or a string specifying the bin algorithm
+ * @param range - Lower and upper range of bins. If not provided, uses [a.min(), a.max()]
+ * @param weights - Optional weights for each data point (used for some algorithms)
+ * @returns Array of bin edges (length = bins + 1)
+ */
+export declare function histogram_bin_edges(a: ArrayStorage, bins?: number | 'auto' | 'fd' | 'doane' | 'scott' | 'stone' | 'rice' | 'sturges' | 'sqrt', range?: [number, number], _weights?: ArrayStorage): ArrayStorage;
+/**
+ * Integrate along the given axis using the composite trapezoidal rule.
+ *
+ * @param y - Input array to integrate
+ * @param x - Optional sample points corresponding to y values. If not provided, spacing is assumed to be 1.
+ * @param dx - Spacing between sample points when x is not given (default: 1.0)
+ * @param axis - The axis along which to integrate (default: -1, meaning last axis)
+ * @returns Definite integral approximated using the composite trapezoidal rule
+ */
+export declare function trapezoid(y: ArrayStorage, x?: ArrayStorage, dx?: number, axis?: number): ArrayStorage | number;
 //# sourceMappingURL=statistics.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "numpy-ts",
-  "version": "0.11.0",
-  "description": "Complete NumPy implementation for TypeScript and JavaScript (under construction)",
+  "version": "0.12.0",
+  "description": "Complete NumPy implementation for TypeScript and JavaScript (81% API coverage)",
   "main": "dist/numpy-ts.node.cjs",
   "browser": "dist/numpy-ts.browser.js",
   "module": "dist/numpy-ts.esm.js",
@@ -105,7 +105,7 @@
     "@vitest/coverage-v8": "^4.0.3",
     "chart.js": "^4.5.1",
     "chartjs-node-canvas": "^5.0.0",
-    "esbuild": "^0.25.11",
+    "esbuild": "^0.27.2",
     "eslint": "^9.38.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-prettier": "^5.0.1",