numpy-ts 0.6.0 → 0.7.0

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

@@ -284,6 +284,46 @@ export declare class NDArray {
      * @returns Boolean array (represented as uint8: 1=true, 0=false)
      */
     allclose(other: NDArray | number, rtol?: number, atol?: number): boolean;
+    /**
+     * Bitwise AND element-wise
+     * @param other - Array or scalar for AND operation (must be integer type)
+     * @returns Result of bitwise AND
+     */
+    bitwise_and(other: NDArray | number): NDArray;
+    /**
+     * Bitwise OR element-wise
+     * @param other - Array or scalar for OR operation (must be integer type)
+     * @returns Result of bitwise OR
+     */
+    bitwise_or(other: NDArray | number): NDArray;
+    /**
+     * Bitwise XOR element-wise
+     * @param other - Array or scalar for XOR operation (must be integer type)
+     * @returns Result of bitwise XOR
+     */
+    bitwise_xor(other: NDArray | number): NDArray;
+    /**
+     * Bitwise NOT (inversion) element-wise
+     * @returns Result of bitwise NOT
+     */
+    bitwise_not(): NDArray;
+    /**
+     * Invert (bitwise NOT) element-wise - alias for bitwise_not
+     * @returns Result of bitwise inversion
+     */
+    invert(): NDArray;
+    /**
+     * Left shift elements by positions
+     * @param shift - Shift amount (array or scalar)
+     * @returns Result of left shift
+     */
+    left_shift(shift: NDArray | number): NDArray;
+    /**
+     * Right shift elements by positions
+     * @param shift - Shift amount (array or scalar)
+     * @returns Result of right shift
+     */
+    right_shift(shift: NDArray | number): NDArray;
     /**
      * Sum array elements over a given axis
      * @param axis - Axis along which to sum. If undefined, sum all elements
@@ -1726,6 +1766,84 @@ export declare function remainder(x: NDArray, y: NDArray | number): NDArray;
  * @returns Array with heaviside values (0 if x1 < 0, x2 if x1 == 0, 1 if x1 > 0)
  */
 export declare function heaviside(x1: NDArray, x2: NDArray | number): NDArray;
+/**
+ * Bitwise AND element-wise
+ *
+ * @param x1 - First input array (must be integer type)
+ * @param x2 - Second input array or scalar (must be integer type)
+ * @returns Result of bitwise AND
+ */
+export declare function bitwise_and(x1: NDArray, x2: NDArray | number): NDArray;
+/**
+ * Bitwise OR element-wise
+ *
+ * @param x1 - First input array (must be integer type)
+ * @param x2 - Second input array or scalar (must be integer type)
+ * @returns Result of bitwise OR
+ */
+export declare function bitwise_or(x1: NDArray, x2: NDArray | number): NDArray;
+/**
+ * Bitwise XOR element-wise
+ *
+ * @param x1 - First input array (must be integer type)
+ * @param x2 - Second input array or scalar (must be integer type)
+ * @returns Result of bitwise XOR
+ */
+export declare function bitwise_xor(x1: NDArray, x2: NDArray | number): NDArray;
+/**
+ * Bitwise NOT (inversion) element-wise
+ *
+ * @param x - Input array (must be integer type)
+ * @returns Result of bitwise NOT
+ */
+export declare function bitwise_not(x: NDArray): NDArray;
+/**
+ * Invert (bitwise NOT) element-wise
+ * Alias for bitwise_not
+ *
+ * @param x - Input array (must be integer type)
+ * @returns Result of bitwise inversion
+ */
+export declare function invert(x: NDArray): NDArray;
+/**
+ * Left shift elements by positions
+ *
+ * @param x1 - Input array (must be integer type)
+ * @param x2 - Shift amount (array or scalar)
+ * @returns Result of left shift
+ */
+export declare function left_shift(x1: NDArray, x2: NDArray | number): NDArray;
+/**
+ * Right shift elements by positions
+ *
+ * @param x1 - Input array (must be integer type)
+ * @param x2 - Shift amount (array or scalar)
+ * @returns Result of right shift
+ */
+export declare function right_shift(x1: NDArray, x2: NDArray | number): NDArray;
+/**
+ * Pack binary values into uint8 array
+ *
+ * Packs the elements of a binary-valued array into bits in a uint8 array.
+ *
+ * @param a - Input array (values are interpreted as binary: 0 or non-zero)
+ * @param axis - The dimension over which bit-packing is done (default: -1)
+ * @param bitorder - Order of bits: 'big' or 'little' (default: 'big')
+ * @returns Packed uint8 array
+ */
+export declare function packbits(a: NDArray, axis?: number, bitorder?: 'big' | 'little'): NDArray;
+/**
+ * Unpack uint8 array into binary values
+ *
+ * Unpacks elements of a uint8 array into a binary-valued output array.
+ *
+ * @param a - Input uint8 array
+ * @param axis - The dimension over which bit-unpacking is done (default: -1)
+ * @param count - Number of elements to unpack, or -1 for all (default: -1)
+ * @param bitorder - Order of bits: 'big' or 'little' (default: 'big')
+ * @returns Unpacked uint8 array of 0s and 1s
+ */
+export declare function unpackbits(a: NDArray, axis?: number, count?: number, bitorder?: 'big' | 'little'): NDArray;
 /**
  * Einstein summation convention
  *
@@ -1748,4 +1866,149 @@ export declare function heaviside(x1: NDArray, x2: NDArray | number): NDArray;
  * einsum('ii->', a)
  */
 export declare function einsum(subscripts: string, ...operands: NDArray[]): NDArray | number | bigint;
+/**
+ * Take values from the input array by matching 1d index and data slices along axis.
+ *
+ * @param arr - Input array
+ * @param indices - Index array with same ndim as arr
+ * @param axis - The axis along which to select values
+ * @returns Array of values taken along the axis
+ */
+export declare function take_along_axis(arr: NDArray, indices: NDArray, axis: number): NDArray;
+/**
+ * Put values into the destination array using 1d index and data slices along axis.
+ *
+ * @param arr - Destination array (modified in-place)
+ * @param indices - Index array with same ndim as arr
+ * @param values - Values to put
+ * @param axis - The axis along which to put values
+ */
+export declare function put_along_axis(arr: NDArray, indices: NDArray, values: NDArray, axis: number): void;
+/**
+ * Change elements of array based on conditional mask.
+ *
+ * @param a - Array to modify (in-place)
+ * @param mask - Boolean mask array
+ * @param values - Values to put where mask is True
+ */
+export declare function putmask(a: NDArray, mask: NDArray, values: NDArray | number | bigint): void;
+/**
+ * Return selected slices of array along given axis.
+ *
+ * @param condition - Boolean array for selecting
+ * @param a - Array from which to select
+ * @param axis - Axis along which to select (if undefined, works on flattened array)
+ * @returns Compressed array
+ */
+export declare function compress(condition: NDArray, a: NDArray, axis?: number): NDArray;
+/**
+ * Return an array drawn from elements in choicelist, depending on conditions.
+ *
+ * @param condlist - List of boolean arrays (conditions)
+ * @param choicelist - List of arrays to choose from
+ * @param defaultVal - Default value when no condition is met (default 0)
+ * @returns Array with selected values
+ */
+export declare function select(condlist: NDArray[], choicelist: NDArray[], defaultVal?: number | bigint): NDArray;
+/**
+ * Change elements of an array based on conditional and input values.
+ *
+ * @param arr - Array to modify (in-place)
+ * @param mask - Boolean mask array
+ * @param vals - Values to place where mask is True (cycles if shorter)
+ */
+export declare function place(arr: NDArray, mask: NDArray, vals: NDArray): void;
+/**
+ * Return the indices to access the main diagonal of an array.
+ *
+ * @param n - Size of arrays for which indices are returned
+ * @param ndim - Number of dimensions (default 2)
+ * @returns Tuple of index arrays
+ */
+export declare function diag_indices(n: number, ndim?: number): NDArray[];
+/**
+ * Return the indices to access the main diagonal of an n-dimensional array.
+ *
+ * @param arr - Input array (must have all equal dimensions)
+ * @returns Tuple of index arrays
+ */
+export declare function diag_indices_from(arr: NDArray): NDArray[];
+/**
+ * Return the indices for the lower-triangle of an (n, m) array.
+ *
+ * @param n - Number of rows
+ * @param k - Diagonal offset (0 = main, positive = above, negative = below)
+ * @param m - Number of columns (default n)
+ * @returns Tuple of row and column index arrays
+ */
+export declare function tril_indices(n: number, k?: number, m?: number): NDArray[];
+/**
+ * Return the indices for the lower-triangle of arr.
+ *
+ * @param arr - Input 2-D array
+ * @param k - Diagonal offset (0 = main, positive = above, negative = below)
+ * @returns Tuple of row and column index arrays
+ */
+export declare function tril_indices_from(arr: NDArray, k?: number): NDArray[];
+/**
+ * Return the indices for the upper-triangle of an (n, m) array.
+ *
+ * @param n - Number of rows
+ * @param k - Diagonal offset (0 = main, positive = above, negative = below)
+ * @param m - Number of columns (default n)
+ * @returns Tuple of row and column index arrays
+ */
+export declare function triu_indices(n: number, k?: number, m?: number): NDArray[];
+/**
+ * Return the indices for the upper-triangle of arr.
+ *
+ * @param arr - Input 2-D array
+ * @param k - Diagonal offset (0 = main, positive = above, negative = below)
+ * @returns Tuple of row and column index arrays
+ */
+export declare function triu_indices_from(arr: NDArray, k?: number): NDArray[];
+/**
+ * Return the indices to access (n, n) arrays, given a masking function.
+ *
+ * @param n - The returned indices will be valid to access arrays of shape (n, n)
+ * @param mask_func - A function that generates an (n, n) boolean mask
+ * @param k - Optional diagonal offset passed to mask_func
+ * @returns Tuple of row and column index arrays
+ */
+export declare function mask_indices(n: number, mask_func: (n: number, k: number) => NDArray, k?: number): NDArray[];
+/**
+ * Return an array representing the indices of a grid.
+ *
+ * @param dimensions - The shape of the grid
+ * @param dtype - Data type of result (default 'int32')
+ * @returns Array of shape (len(dimensions), *dimensions)
+ */
+export declare function indices(dimensions: number[], dtype?: 'int32' | 'int64' | 'float64'): NDArray;
+/**
+ * Construct an open mesh from multiple sequences.
+ *
+ * This function returns a list of arrays with shapes suitable for broadcasting.
+ *
+ * @param args - 1-D sequences
+ * @returns Tuple of arrays for open mesh
+ */
+export declare function ix_(...args: NDArray[]): NDArray[];
+/**
+ * Convert a tuple of index arrays into an array of flat indices.
+ *
+ * @param multi_index - Tuple of index arrays
+ * @param dims - Shape of array into which indices apply
+ * @param mode - How to handle out-of-bounds indices ('raise', 'wrap', 'clip')
+ * @returns Flattened indices
+ */
+export declare function ravel_multi_index(multi_index: NDArray[], dims: number[], mode?: 'raise' | 'wrap' | 'clip'): NDArray;
+/**
+ * Convert a flat index or array of flat indices into a tuple of coordinate arrays.
+ *
+ * @param indices - Array of indices or single index
+ * @param shape - Shape of the array to index into
+ * @param order - Row-major ('C') or column-major ('F') order
+ * @returns Tuple of coordinate arrays
+ */
+export declare function unravel_index(indices: NDArray | number, shape: number[], order?: 'C' | 'F'): NDArray[];
 //# sourceMappingURL=ndarray.d.ts.map

package/dist/types/index.d.ts

@@ -3,7 +3,7 @@
  *
  * @module numpy-ts
  */
-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, absolute, negative, sign, mod, floor_divide, positive, reciprocal, cbrt, fabs, divmod, square, remainder, heaviside, dot, trace, diagonal, kron, transpose, inner, outer, tensordot, einsum, sin, cos, tan, arcsin, arccos, arctan, arctan2, hypot, degrees, radians, deg2rad, rad2deg, sinh, cosh, tanh, arcsinh, arccosh, 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, choose, array_equal, array_equiv, cumsum, cumprod, ptp, median, percentile, quantile, average, nansum, nanprod, nanmean, nanvar, nanstd, nanmin, nanmax, nanargmin, nanargmax, nancumsum, nancumprod, nanmedian, } from './core/ndarray';
+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, absolute, negative, sign, mod, floor_divide, positive, reciprocal, cbrt, fabs, divmod, square, remainder, heaviside, dot, trace, diagonal, kron, transpose, inner, outer, tensordot, einsum, sin, cos, tan, arcsin, arccos, arctan, arctan2, hypot, degrees, radians, deg2rad, rad2deg, sinh, cosh, tanh, arcsinh, arccosh, 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, choose, array_equal, array_equiv, take_along_axis, put_along_axis, putmask, compress, select, place, 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, cumprod, 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, } 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';
 export declare const __version__: string;
 //# sourceMappingURL=index.d.ts.map

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

@@ -37,4 +37,72 @@ export declare function choose(indexStorage: ArrayStorage, choices: ArrayStorage
  * Check if two arrays are element-wise equal
  */
 export declare function array_equal(a: ArrayStorage, b: ArrayStorage, equal_nan?: boolean): boolean;
+/**
+ * Take values along an axis using 1D index array
+ */
+export declare function take_along_axis(storage: ArrayStorage, indices: ArrayStorage, axis: number): ArrayStorage;
+/**
+ * Put values into array along an axis using 1D index array
+ */
+export declare function put_along_axis(storage: ArrayStorage, indices: ArrayStorage, values: ArrayStorage, axis: number): void;
+/**
+ * Change elements of array based on conditional mask
+ */
+export declare function putmask(storage: ArrayStorage, mask: ArrayStorage, values: ArrayStorage | number | bigint): void;
+/**
+ * Return selected slices along given axis based on condition
+ */
+export declare function compress(condition: ArrayStorage, storage: ArrayStorage, axis?: number): ArrayStorage;
+/**
+ * Return array drawn from elements in choicelist, depending on conditions
+ */
+export declare function select(condlist: ArrayStorage[], choicelist: ArrayStorage[], defaultValue?: number | bigint): ArrayStorage;
+/**
+ * Change elements of array based on conditional and input values
+ */
+export declare function place(storage: ArrayStorage, mask: ArrayStorage, vals: ArrayStorage): void;
+/**
+ * Return indices to access main diagonal of array
+ */
+export declare function diag_indices(n: number, ndim?: number): ArrayStorage[];
+/**
+ * Return indices to access main diagonal of array from given array
+ */
+export declare function diag_indices_from(storage: ArrayStorage): ArrayStorage[];
+/**
+ * Return indices for lower-triangle of an (n, m) array
+ */
+export declare function tril_indices(n: number, k?: number, m?: number): ArrayStorage[];
+/**
+ * Return indices for lower-triangle of given array
+ */
+export declare function tril_indices_from(storage: ArrayStorage, k?: number): ArrayStorage[];
+/**
+ * Return indices for upper-triangle of an (n, m) array
+ */
+export declare function triu_indices(n: number, k?: number, m?: number): ArrayStorage[];
+/**
+ * Return indices for upper-triangle of given array
+ */
+export declare function triu_indices_from(storage: ArrayStorage, k?: number): ArrayStorage[];
+/**
+ * Return indices to access elements using mask function
+ */
+export declare function mask_indices(n: number, mask_func: (n: number, k: number) => ArrayStorage, k?: number): ArrayStorage[];
+/**
+ * Return array representing indices of a grid
+ */
+export declare function indices(dimensions: number[], dtype?: 'int32' | 'int64' | 'float64'): ArrayStorage;
+/**
+ * Construct open mesh from multiple sequences
+ */
+export declare function ix_(...args: ArrayStorage[]): ArrayStorage[];
+/**
+ * Convert multi-dimensional index arrays to flat index array
+ */
+export declare function ravel_multi_index(multi_index: ArrayStorage[], dims: number[], mode?: 'raise' | 'wrap' | 'clip'): ArrayStorage;
+/**
+ * Convert flat index array to tuple of coordinate arrays
+ */
+export declare function unravel_index(indices: ArrayStorage | number, shape: number[], order?: 'C' | 'F'): ArrayStorage[];
 //# sourceMappingURL=advanced.d.ts.map

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

@@ -0,0 +1,91 @@
+/**
+ * Bitwise operations
+ *
+ * Pure functions for element-wise bitwise operations:
+ * bitwise_and, bitwise_or, bitwise_xor, bitwise_not, invert,
+ * left_shift, right_shift, packbits, unpackbits
+ *
+ * These operations only work on integer types.
+ */
+import { ArrayStorage } from '../core/storage';
+/**
+ * Bitwise AND of two arrays or array and scalar
+ *
+ * @param a - First array storage (must be integer type)
+ * @param b - Second array storage or scalar (must be integer type)
+ * @returns Result storage
+ */
+export declare function bitwise_and(a: ArrayStorage, b: ArrayStorage | number): ArrayStorage;
+/**
+ * Bitwise OR of two arrays or array and scalar
+ *
+ * @param a - First array storage (must be integer type)
+ * @param b - Second array storage or scalar (must be integer type)
+ * @returns Result storage
+ */
+export declare function bitwise_or(a: ArrayStorage, b: ArrayStorage | number): ArrayStorage;
+/**
+ * Bitwise XOR of two arrays or array and scalar
+ *
+ * @param a - First array storage (must be integer type)
+ * @param b - Second array storage or scalar (must be integer type)
+ * @returns Result storage
+ */
+export declare function bitwise_xor(a: ArrayStorage, b: ArrayStorage | number): ArrayStorage;
+/**
+ * Bitwise NOT (invert) of each element
+ *
+ * @param a - Input array storage (must be integer type)
+ * @returns Result storage with bitwise NOT values
+ */
+export declare function bitwise_not(a: ArrayStorage): ArrayStorage;
+/**
+ * Invert (bitwise NOT) - alias for bitwise_not
+ *
+ * @param a - Input array storage (must be integer type)
+ * @returns Result storage with inverted values
+ */
+export declare function invert(a: ArrayStorage): ArrayStorage;
+/**
+ * Left shift of array elements
+ *
+ * @param a - Input array storage (must be integer type)
+ * @param b - Shift amount (array storage or scalar)
+ * @returns Result storage with left-shifted values
+ */
+export declare function left_shift(a: ArrayStorage, b: ArrayStorage | number): ArrayStorage;
+/**
+ * Right shift of array elements
+ *
+ * @param a - Input array storage (must be integer type)
+ * @param b - Shift amount (array storage or scalar)
+ * @returns Result storage with right-shifted values
+ */
+export declare function right_shift(a: ArrayStorage, b: ArrayStorage | number): ArrayStorage;
+/**
+ * Pack binary values into uint8 array
+ *
+ * Packs the elements of a binary-valued array into bits in a uint8 array.
+ * The result has the same shape as the input, except for the specified axis
+ * which is divided by 8 (rounded up).
+ *
+ * @param a - Input array (values are interpreted as binary: 0 or non-zero)
+ * @param axis - The dimension over which bit-packing is done (default: -1, meaning the last axis)
+ * @param bitorder - The order of bits within each packed byte. 'big' means the most significant bit is first. (default: 'big')
+ * @returns Packed uint8 array
+ */
+export declare function packbits(a: ArrayStorage, axis?: number, bitorder?: 'big' | 'little'): ArrayStorage;
+/**
+ * Unpack uint8 array into binary values
+ *
+ * Unpacks elements of a uint8 array into a binary-valued output array.
+ * Each element of the input array is unpacked into 8 binary values.
+ *
+ * @param a - Input uint8 array
+ * @param axis - The dimension over which bit-unpacking is done (default: -1, meaning the last axis)
+ * @param count - The number of elements to unpack along axis, or -1 for all (default: -1)
+ * @param bitorder - The order of bits within each packed byte. 'big' means the most significant bit is first. (default: 'big')
+ * @returns Unpacked uint8 array of 0s and 1s
+ */
+export declare function unpackbits(a: ArrayStorage, axis?: number, count?: number, bitorder?: 'big' | 'little'): ArrayStorage;
+//# sourceMappingURL=bitwise.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "numpy-ts",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Complete NumPy implementation for TypeScript and JavaScript (under construction)",
   "main": "dist/numpy-ts.node.cjs",
   "browser": "dist/numpy-ts.browser.js",