numpy-ts 0.5.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
@@ -363,6 +403,137 @@ export declare class NDArray {
      * @returns Boolean or array of booleans
      */
     any(axis?: number, keepdims?: boolean): NDArray | boolean;
+    /**
+     * Return the cumulative sum of elements along a given axis
+     * @param axis - Axis along which to compute cumsum. If undefined, compute over flattened array.
+     * @returns Array with cumulative sums
+     */
+    cumsum(axis?: number): NDArray;
+    /**
+     * Return the cumulative product of elements along a given axis
+     * @param axis - Axis along which to compute cumprod. If undefined, compute over flattened array.
+     * @returns Array with cumulative products
+     */
+    cumprod(axis?: number): NDArray;
+    /**
+     * Peak to peak (maximum - minimum) value along a given axis
+     * @param axis - Axis along which to compute ptp. If undefined, compute over all elements.
+     * @param keepdims - If true, reduced axes are left as dimensions with size 1
+     * @returns Range of values
+     */
+    ptp(axis?: number, keepdims?: boolean): NDArray | number;
+    /**
+     * Compute the median along the specified axis
+     * @param axis - Axis along which to compute median. If undefined, compute over all elements.
+     * @param keepdims - If true, reduced axes are left as dimensions with size 1
+     * @returns Median of array elements
+     */
+    median(axis?: number, keepdims?: boolean): NDArray | number;
+    /**
+     * Compute the q-th percentile of the data along the specified axis
+     * @param q - Percentile to compute (0-100)
+     * @param axis - Axis along which to compute percentile. If undefined, compute over all elements.
+     * @param keepdims - If true, reduced axes are left as dimensions with size 1
+     * @returns Percentile of array elements
+     */
+    percentile(q: number, axis?: number, keepdims?: boolean): NDArray | number;
+    /**
+     * Compute the q-th quantile of the data along the specified axis
+     * @param q - Quantile to compute (0-1)
+     * @param axis - Axis along which to compute quantile. If undefined, compute over all elements.
+     * @param keepdims - If true, reduced axes are left as dimensions with size 1
+     * @returns Quantile of array elements
+     */
+    quantile(q: number, axis?: number, keepdims?: boolean): NDArray | number;
+    /**
+     * Compute the weighted average along the specified axis
+     * @param weights - Array of weights (optional)
+     * @param axis - Axis along which to compute average. If undefined, compute over all elements.
+     * @returns Weighted average of array elements
+     */
+    average(weights?: NDArray, axis?: number): NDArray | number;
+    /**
+     * Return the sum of array elements, treating NaNs as zero
+     * @param axis - Axis along which to compute sum. If undefined, compute over all elements.
+     * @param keepdims - If true, reduced axes are left as dimensions with size 1
+     * @returns Sum of array elements ignoring NaNs
+     */
+    nansum(axis?: number, keepdims?: boolean): NDArray | number;
+    /**
+     * Return the product of array elements, treating NaNs as ones
+     * @param axis - Axis along which to compute product. If undefined, compute over all elements.
+     * @param keepdims - If true, reduced axes are left as dimensions with size 1
+     * @returns Product of array elements ignoring NaNs
+     */
+    nanprod(axis?: number, keepdims?: boolean): NDArray | number;
+    /**
+     * Compute the arithmetic mean, ignoring NaNs
+     * @param axis - Axis along which to compute mean. If undefined, compute over all elements.
+     * @param keepdims - If true, reduced axes are left as dimensions with size 1
+     * @returns Mean of array elements ignoring NaNs
+     */
+    nanmean(axis?: number, keepdims?: boolean): NDArray | number;
+    /**
+     * Compute the variance, ignoring NaNs
+     * @param axis - Axis along which to compute variance. If undefined, compute over all elements.
+     * @param ddof - Delta degrees of freedom (default: 0)
+     * @param keepdims - If true, reduced axes are left as dimensions with size 1
+     * @returns Variance of array elements ignoring NaNs
+     */
+    nanvar(axis?: number, ddof?: number, keepdims?: boolean): NDArray | number;
+    /**
+     * Compute the standard deviation, ignoring NaNs
+     * @param axis - Axis along which to compute std. If undefined, compute over all elements.
+     * @param ddof - Delta degrees of freedom (default: 0)
+     * @param keepdims - If true, reduced axes are left as dimensions with size 1
+     * @returns Standard deviation of array elements ignoring NaNs
+     */
+    nanstd(axis?: number, ddof?: number, keepdims?: boolean): NDArray | number;
+    /**
+     * Return minimum of an array or minimum along an axis, ignoring NaNs
+     * @param axis - Axis along which to compute minimum. If undefined, compute over all elements.
+     * @param keepdims - If true, reduced axes are left as dimensions with size 1
+     * @returns Minimum of array elements ignoring NaNs
+     */
+    nanmin(axis?: number, keepdims?: boolean): NDArray | number;
+    /**
+     * Return maximum of an array or maximum along an axis, ignoring NaNs
+     * @param axis - Axis along which to compute maximum. If undefined, compute over all elements.
+     * @param keepdims - If true, reduced axes are left as dimensions with size 1
+     * @returns Maximum of array elements ignoring NaNs
+     */
+    nanmax(axis?: number, keepdims?: boolean): NDArray | number;
+    /**
+     * Return the indices of the minimum values, ignoring NaNs
+     * @param axis - Axis along which to find minimum indices. If undefined, index of global minimum.
+     * @returns Indices of minimum values ignoring NaNs
+     */
+    nanargmin(axis?: number): NDArray | number;
+    /**
+     * Return the indices of the maximum values, ignoring NaNs
+     * @param axis - Axis along which to find maximum indices. If undefined, index of global maximum.
+     * @returns Indices of maximum values ignoring NaNs
+     */
+    nanargmax(axis?: number): NDArray | number;
+    /**
+     * Return the cumulative sum of elements, treating NaNs as zero
+     * @param axis - Axis along which to compute cumsum. If undefined, compute over flattened array.
+     * @returns Array with cumulative sums ignoring NaNs
+     */
+    nancumsum(axis?: number): NDArray;
+    /**
+     * Return the cumulative product of elements, treating NaNs as one
+     * @param axis - Axis along which to compute cumprod. If undefined, compute over flattened array.
+     * @returns Array with cumulative products ignoring NaNs
+     */
+    nancumprod(axis?: number): NDArray;
+    /**
+     * Compute the median, ignoring NaNs
+     * @param axis - Axis along which to compute median. If undefined, compute over all elements.
+     * @param keepdims - If true, reduced axes are left as dimensions with size 1
+     * @returns Median of array elements ignoring NaNs
+     */
+    nanmedian(axis?: number, keepdims?: boolean): NDArray | number;
     /**
      * Reshape array to a new shape
      * Returns a new array with the specified shape
@@ -468,6 +639,40 @@ export declare class NDArray {
      * @returns Tensor dot product result
      */
     tensordot(other: NDArray, axes?: number | [number[], number[]]): NDArray | number | bigint;
+    /**
+     * Element-wise cube root
+     * Promotes integer types to float64
+     * @returns New array with cube root values
+     */
+    cbrt(): NDArray;
+    /**
+     * Element-wise absolute value (always returns float)
+     * @returns New array with absolute values as float
+     */
+    fabs(): NDArray;
+    /**
+     * Returns both quotient and remainder (floor divide and modulo)
+     * @param divisor - Array or scalar divisor
+     * @returns Tuple of [quotient, remainder] arrays
+     */
+    divmod(divisor: NDArray | number): [NDArray, NDArray];
+    /**
+     * Element-wise square (x**2)
+     * @returns New array with squared values
+     */
+    square(): NDArray;
+    /**
+     * Element-wise remainder (same as mod)
+     * @param divisor - Array or scalar divisor
+     * @returns New array with remainder values
+     */
+    remainder(divisor: NDArray | number): NDArray;
+    /**
+     * Heaviside step function
+     * @param x2 - Value to use when this array element is 0
+     * @returns New array with heaviside values
+     */
+    heaviside(x2: NDArray | number): NDArray;
     /**
      * Slice the array using NumPy-style string syntax
      *
@@ -647,6 +852,130 @@ export declare function empty_like(a: NDArray, dtype?: DType): NDArray;
  * @returns Filled array
  */
 export declare function full_like(a: NDArray, fill_value: number | bigint | boolean, dtype?: DType): NDArray;
+/**
+ * Convert input to an ndarray (alias for asarray for compatibility)
+ * In numpy-ts, this behaves the same as asarray since we don't have subclasses
+ * @param a - Input data
+ * @param dtype - Data type (optional)
+ * @returns NDArray
+ */
+export declare function asanyarray(a: NDArray | any, dtype?: DType): NDArray;
+/**
+ * Return a contiguous array (ndim >= 1) in memory (C order)
+ * Since our arrays are already C-contiguous in memory, this either
+ * returns the input unchanged or creates a contiguous copy
+ * @param a - Input data
+ * @param dtype - Data type (optional)
+ * @returns Contiguous array in C order
+ */
+export declare function ascontiguousarray(a: NDArray | any, dtype?: DType): NDArray;
+/**
+ * Return an array laid out in Fortran order in memory
+ * Note: numpy-ts uses C-order internally, so this creates a copy
+ * that is equivalent to the Fortran-ordered layout
+ * @param a - Input data
+ * @param dtype - Data type (optional)
+ * @returns Array (copy in C order, as Fortran order is not supported)
+ */
+export declare function asfortranarray(a: NDArray | any, dtype?: DType): NDArray;
+/**
+ * Extract a diagonal or construct a diagonal array
+ * @param v - Input array (if 2D, extract diagonal; if 1D, construct diagonal matrix)
+ * @param k - Diagonal offset (default 0 is main diagonal, positive above, negative below)
+ * @returns Diagonal elements as 1D array, or 2D diagonal matrix
+ */
+export declare function diag(v: NDArray, k?: number): NDArray;
+/**
+ * Create a 2-D array with the flattened input as a diagonal
+ * @param v - Input array (will be flattened)
+ * @param k - Diagonal offset (default 0)
+ * @returns 2D diagonal matrix
+ */
+export declare function diagflat(v: NDArray, k?: number): NDArray;
+/**
+ * Construct an array by executing a function over each coordinate
+ * @param fn - Function that takes coordinate indices and returns value
+ * @param shape - Shape of output array
+ * @param dtype - Data type (default: float64)
+ * @returns Array with values computed from function
+ */
+export declare function fromfunction(fn: (...indices: number[]) => number | bigint | boolean, shape: number[], dtype?: DType): NDArray;
+/**
+ * Return coordinate matrices from coordinate vectors
+ * @param arrays - 1D coordinate arrays
+ * @param indexing - 'xy' (Cartesian, default) or 'ij' (matrix indexing)
+ * @returns Array of coordinate grids
+ */
+export declare function meshgrid(...args: (NDArray | {
+    indexing?: 'xy' | 'ij';
+})[]): NDArray[];
+/**
+ * An array with ones at and below the given diagonal and zeros elsewhere
+ * @param N - Number of rows
+ * @param M - Number of columns (default: N)
+ * @param k - Diagonal offset (default 0)
+ * @param dtype - Data type (default: float64)
+ * @returns Triangular array
+ */
+export declare function tri(N: number, M?: number, k?: number, dtype?: DType): NDArray;
+/**
+ * Lower triangle of an array
+ * @param m - Input array
+ * @param k - Diagonal above which to zero elements (default 0)
+ * @returns Copy with upper triangle zeroed
+ */
+export declare function tril(m: NDArray, k?: number): NDArray;
+/**
+ * Upper triangle of an array
+ * @param m - Input array
+ * @param k - Diagonal below which to zero elements (default 0)
+ * @returns Copy with lower triangle zeroed
+ */
+export declare function triu(m: NDArray, k?: number): NDArray;
+/**
+ * Generate a Vandermonde matrix
+ * @param x - Input 1D array
+ * @param N - Number of columns (default: length of x)
+ * @param increasing - Order of powers (default: false, highest powers first)
+ * @returns Vandermonde matrix
+ */
+export declare function vander(x: NDArray, N?: number, increasing?: boolean): NDArray;
+/**
+ * Interpret a buffer as a 1-dimensional array
+ * @param buffer - Buffer-like object (ArrayBuffer, TypedArray, or DataView)
+ * @param dtype - Data type (default: float64)
+ * @param count - Number of items to read (-1 means all)
+ * @param offset - Start reading from this byte offset
+ * @returns NDArray from buffer data
+ */
+export declare function frombuffer(buffer: ArrayBuffer | ArrayBufferView, dtype?: DType, count?: number, offset?: number): NDArray;
+/**
+ * Construct an array by executing a function over each coordinate.
+ * Note: This is a JS implementation - fromfile for actual files isn't directly applicable in browser JS.
+ * This function creates an array from an iterable or callable.
+ * @param file - In JS context, this is an iterable yielding values
+ * @param dtype - Data type
+ * @param count - Number of items to read (-1 means all)
+ * @returns NDArray from the iterable
+ */
+export declare function fromfile(file: Iterable<number | bigint>, dtype?: DType, count?: number): NDArray;
+/**
+ * Create a new 1-dimensional array from an iterable object
+ * @param iter - Iterable object
+ * @param dtype - Data type
+ * @param count - Number of items to read (-1 means all)
+ * @returns NDArray from the iterable
+ */
+export declare function fromiter(iter: Iterable<number | bigint>, dtype?: DType, count?: number): NDArray;
+/**
+ * Create a new 1-dimensional array from text string
+ * @param string - Input string containing numbers separated by whitespace or separator
+ * @param dtype - Data type (default: float64)
+ * @param count - Number of items to read (-1 means all)
+ * @param sep - Separator between values (default: any whitespace)
+ * @returns NDArray from parsed string
+ */
+export declare function fromstring(string: string, dtype?: DType, count?: number, sep?: string): NDArray;
 /**
  * Element-wise square root
  * @param x - Input array
@@ -730,6 +1059,24 @@ export declare function dot(a: NDArray, b: NDArray): NDArray | number | bigint;
  * @returns Sum of diagonal elements
  */
 export declare function trace(a: NDArray): number | bigint;
+/**
+ * Extract a diagonal from a matrix or N-D array
+ *
+ * @param a - Input array (must be at least 2D)
+ * @param offset - Offset of the diagonal from the main diagonal (default: 0)
+ * @param axis1 - First axis (default: 0)
+ * @param axis2 - Second axis (default: 1)
+ * @returns Array containing the diagonal elements
+ */
+export declare function diagonal(a: NDArray, offset?: number, axis1?: number, axis2?: number): NDArray;
+/**
+ * Kronecker product of two arrays
+ *
+ * @param a - First input array
+ * @param b - Second input array
+ * @returns Kronecker product of a and b
+ */
+export declare function kron(a: NDArray, b: NDArray): NDArray;
 /**
  * Permute array dimensions
  *
@@ -831,6 +1178,18 @@ export declare function degrees(x: NDArray): NDArray;
  * @returns Angles in radians
  */
 export declare function radians(x: NDArray): NDArray;
+/**
+ * Convert angles from degrees to radians (alias for radians)
+ * @param x - Input array (angles in degrees)
+ * @returns Angles in radians
+ */
+export declare function deg2rad(x: NDArray): NDArray;
+/**
+ * Convert angles from radians to degrees (alias for degrees)
+ * @param x - Input array (angles in radians)
+ * @returns Angles in degrees
+ */
+export declare function rad2deg(x: NDArray): NDArray;
 /**
  * Element-wise hyperbolic sine
  * @param x - Input array
@@ -973,6 +1332,175 @@ export declare function tile(a: NDArray, reps: number | number[]): NDArray;
  * @returns Array with repeated elements
  */
 export declare function repeat(a: NDArray, repeats: number | number[], axis?: number): NDArray;
+/**
+ * Return a contiguous flattened array
+ *
+ * @param a - Input array
+ * @returns Flattened 1-D array (view if possible)
+ */
+export declare function ravel(a: NDArray): NDArray;
+/**
+ * Reshape array to new shape
+ *
+ * @param a - Input array
+ * @param newShape - New shape
+ * @returns Reshaped array (view if possible)
+ */
+export declare function reshape(a: NDArray, newShape: number[]): NDArray;
+/**
+ * Remove axes of length 1
+ *
+ * @param a - Input array
+ * @param axis - Axis to squeeze (optional, squeezes all if not specified)
+ * @returns Squeezed array (view)
+ */
+export declare function squeeze(a: NDArray, axis?: number): NDArray;
+/**
+ * Expand the shape of an array by inserting a new axis
+ *
+ * @param a - Input array
+ * @param axis - Position where new axis should be inserted
+ * @returns Array with expanded shape (view)
+ */
+export declare function expand_dims(a: NDArray, axis: number): NDArray;
+/**
+ * Reverse the order of elements along the given axis
+ *
+ * @param m - Input array
+ * @param axis - Axis or axes to flip (flips all if undefined)
+ * @returns Flipped array
+ */
+export declare function flip(m: NDArray, axis?: number | number[]): NDArray;
+/**
+ * Flip array in the left/right direction (reverse along axis 1)
+ *
+ * @param m - Input array (must be at least 2-D)
+ * @returns Flipped array
+ */
+export declare function fliplr(m: NDArray): NDArray;
+/**
+ * Flip array in the up/down direction (reverse along axis 0)
+ *
+ * @param m - Input array (must be at least 2-D)
+ * @returns Flipped array
+ */
+export declare function flipud(m: NDArray): NDArray;
+/**
+ * Rotate array by 90 degrees
+ *
+ * @param m - Input array
+ * @param k - Number of times to rotate (default 1)
+ * @param axes - The axes to rotate in (default [0, 1])
+ * @returns Rotated array
+ */
+export declare function rot90(m: NDArray, k?: number, axes?: [number, number]): NDArray;
+/**
+ * Roll array elements along a given axis
+ *
+ * @param a - Input array
+ * @param shift - Number of positions to shift
+ * @param axis - Axis along which to roll (rolls flattened array if undefined)
+ * @returns Rolled array
+ */
+export declare function roll(a: NDArray, shift: number | number[], axis?: number | number[]): NDArray;
+/**
+ * Roll the specified axis backwards until it lies in a given position
+ *
+ * @param a - Input array
+ * @param axis - The axis to roll backwards
+ * @param start - Position to roll to (default 0)
+ * @returns Array with rolled axis (view)
+ */
+export declare function rollaxis(a: NDArray, axis: number, start?: number): NDArray;
+/**
+ * Convert inputs to arrays with at least 1 dimension
+ *
+ * @param arrays - Input arrays
+ * @returns Arrays with at least 1 dimension
+ */
+export declare function atleast_1d(...arrays: NDArray[]): NDArray | NDArray[];
+/**
+ * Convert inputs to arrays with at least 2 dimensions
+ *
+ * @param arrays - Input arrays
+ * @returns Arrays with at least 2 dimensions
+ */
+export declare function atleast_2d(...arrays: NDArray[]): NDArray | NDArray[];
+/**
+ * Convert inputs to arrays with at least 3 dimensions
+ *
+ * @param arrays - Input arrays
+ * @returns Arrays with at least 3 dimensions
+ */
+export declare function atleast_3d(...arrays: NDArray[]): NDArray | NDArray[];
+/**
+ * Split array along third axis (depth)
+ *
+ * @param ary - Input array (must be at least 3-D)
+ * @param indices_or_sections - Number of sections or indices where to split
+ * @returns List of sub-arrays
+ */
+export declare function dsplit(ary: NDArray, indices_or_sections: number | number[]): NDArray[];
+/**
+ * Stack 1-D arrays as columns into a 2-D array
+ *
+ * @param arrays - 1-D arrays to stack
+ * @returns 2-D array with inputs as columns
+ */
+export declare function column_stack(arrays: NDArray[]): NDArray;
+/**
+ * Stack arrays in sequence vertically (alias for vstack)
+ *
+ * @param arrays - Arrays to stack
+ * @returns Vertically stacked array
+ */
+export declare function row_stack(arrays: NDArray[]): NDArray;
+/**
+ * Return a new array with the given shape (repeating data if needed)
+ *
+ * @param a - Input array
+ * @param new_shape - New shape
+ * @returns Resized array
+ */
+export declare function resize(a: NDArray, new_shape: number[]): NDArray;
+/**
+ * Append values to the end of an array
+ *
+ * @param arr - Input array
+ * @param values - Values to append
+ * @param axis - Axis along which to append (flattens if undefined)
+ * @returns Array with values appended
+ */
+export declare function append(arr: NDArray, values: NDArray | ArrayLike<number | bigint> | number, axis?: number): NDArray;
+/**
+ * Return a new array with sub-arrays along an axis deleted
+ *
+ * @param arr - Input array
+ * @param obj - Indices to delete
+ * @param axis - Axis along which to delete (flattens if undefined)
+ * @returns Array with elements deleted
+ */
+export declare function delete_(arr: NDArray, obj: number | number[], axis?: number): NDArray;
+/**
+ * Insert values along the given axis before the given indices
+ *
+ * @param arr - Input array
+ * @param obj - Index before which to insert
+ * @param values - Values to insert
+ * @param axis - Axis along which to insert (flattens if undefined)
+ * @returns Array with values inserted
+ */
+export declare function insert(arr: NDArray, obj: number, values: NDArray | ArrayLike<number | bigint> | number, axis?: number): NDArray;
+/**
+ * Pad an array
+ *
+ * @param array - Input array
+ * @param pad_width - Number of values padded to edges of each axis
+ * @param mode - Padding mode ('constant', 'edge', 'reflect', 'symmetric', 'wrap')
+ * @param constant_values - Value for constant padding (default 0)
+ * @returns Padded array
+ */
+export declare function pad(arr: NDArray, pad_width: number | [number, number] | Array<[number, number]>, mode?: 'constant' | 'edge' | 'reflect' | 'symmetric' | 'wrap', constant_values?: number): NDArray;
 /**
  * Broadcast an array to a given shape
  *
@@ -988,6 +1516,17 @@ export declare function broadcast_to(a: NDArray, shape: number[]): NDArray;
  * @returns Arrays broadcast to common shape
  */
 export declare function broadcast_arrays(...arrays: NDArray[]): NDArray[];
+/**
+ * Compute the broadcast shape for multiple shapes
+ *
+ * Returns the resulting shape if all shapes are broadcast-compatible.
+ * Throws an error if shapes are not broadcast-compatible.
+ *
+ * @param shapes - Variable number of shapes to broadcast
+ * @returns The broadcast output shape
+ * @throws Error if shapes are not broadcast-compatible
+ */
+export declare function broadcast_shapes(...shapes: number[][]): number[];
 /**
  * Take elements from an array along an axis
  *
@@ -1022,4 +1561,454 @@ export declare function choose(a: NDArray, choices: NDArray[]): NDArray;
  * @returns True if arrays are equal element-wise
  */
 export declare function array_equal(a: NDArray, b: NDArray, equal_nan?: boolean): boolean;
+/**
+ * Returns True if two arrays are element-wise equal within a tolerance.
+ * Unlike array_equal, this function broadcasts the arrays before comparison.
+ *
+ * @param a1 - First input array
+ * @param a2 - Second input array
+ * @returns True if arrays are equivalent (after broadcasting)
+ */
+export declare function array_equiv(a1: NDArray, a2: NDArray): boolean;
+/**
+ * Return the cumulative sum of the elements along a given axis.
+ * @param a - Input array
+ * @param axis - Axis along which to compute. If undefined, flattened array is used.
+ * @returns Array with cumulative sums
+ */
+export declare function cumsum(a: NDArray, axis?: number): NDArray;
+/**
+ * Return the cumulative product of the elements along a given axis.
+ * @param a - Input array
+ * @param axis - Axis along which to compute. If undefined, flattened array is used.
+ * @returns Array with cumulative products
+ */
+export declare function cumprod(a: NDArray, axis?: number): NDArray;
+/**
+ * Peak to peak (maximum - minimum) value along a given axis.
+ * @param a - Input array
+ * @param axis - Axis along which to compute. If undefined, use all elements.
+ * @param keepdims - If true, reduced axes are left as dimensions with size 1
+ * @returns Peak to peak value(s)
+ */
+export declare function ptp(a: NDArray, axis?: number, keepdims?: boolean): NDArray | number;
+/**
+ * Compute the median along the specified axis.
+ * @param a - Input array
+ * @param axis - Axis along which to compute. If undefined, use all elements.
+ * @param keepdims - If true, reduced axes are left as dimensions with size 1
+ * @returns Median value(s)
+ */
+export declare function median(a: NDArray, axis?: number, keepdims?: boolean): NDArray | number;
+/**
+ * Compute the q-th percentile of the data along the specified axis.
+ * @param a - Input array
+ * @param q - Percentile (0-100)
+ * @param axis - Axis along which to compute. If undefined, use all elements.
+ * @param keepdims - If true, reduced axes are left as dimensions with size 1
+ * @returns Percentile value(s)
+ */
+export declare function percentile(a: NDArray, q: number, axis?: number, keepdims?: boolean): NDArray | number;
+/**
+ * Compute the q-th quantile of the data along the specified axis.
+ * @param a - Input array
+ * @param q - Quantile (0-1)
+ * @param axis - Axis along which to compute. If undefined, use all elements.
+ * @param keepdims - If true, reduced axes are left as dimensions with size 1
+ * @returns Quantile value(s)
+ */
+export declare function quantile(a: NDArray, q: number, axis?: number, keepdims?: boolean): NDArray | number;
+/**
+ * Compute the weighted average along the specified axis.
+ * @param a - Input array
+ * @param axis - Axis along which to compute. If undefined, use all elements.
+ * @param weights - Array of weights (must be same shape as array along specified axis)
+ * @param keepdims - If true, reduced axes are left as dimensions with size 1
+ * @returns Weighted average value(s)
+ */
+export declare function average(a: NDArray, axis?: number, weights?: NDArray, keepdims?: boolean): NDArray | number;
+/**
+ * Return the sum of array elements over a given axis, treating NaNs as zero.
+ * @param a - Input array
+ * @param axis - Axis along which to compute. If undefined, use all elements.
+ * @param keepdims - If true, reduced axes are left as dimensions with size 1
+ * @returns Sum value(s)
+ */
+export declare function nansum(a: NDArray, axis?: number, keepdims?: boolean): NDArray | number;
+/**
+ * Return the product of array elements over a given axis, treating NaNs as one.
+ * @param a - Input array
+ * @param axis - Axis along which to compute. If undefined, use all elements.
+ * @param keepdims - If true, reduced axes are left as dimensions with size 1
+ * @returns Product value(s)
+ */
+export declare function nanprod(a: NDArray, axis?: number, keepdims?: boolean): NDArray | number;
+/**
+ * Compute the arithmetic mean along the specified axis, ignoring NaNs.
+ * @param a - Input array
+ * @param axis - Axis along which to compute. If undefined, use all elements.
+ * @param keepdims - If true, reduced axes are left as dimensions with size 1
+ * @returns Mean value(s)
+ */
+export declare function nanmean(a: NDArray, axis?: number, keepdims?: boolean): NDArray | number;
+/**
+ * Compute the variance along the specified axis, ignoring NaNs.
+ * @param a - Input array
+ * @param axis - Axis along which to compute. If undefined, use all elements.
+ * @param ddof - Delta degrees of freedom (default 0)
+ * @param keepdims - If true, reduced axes are left as dimensions with size 1
+ * @returns Variance value(s)
+ */
+export declare function nanvar(a: NDArray, axis?: number, ddof?: number, keepdims?: boolean): NDArray | number;
+/**
+ * Compute the standard deviation along the specified axis, ignoring NaNs.
+ * @param a - Input array
+ * @param axis - Axis along which to compute. If undefined, use all elements.
+ * @param ddof - Delta degrees of freedom (default 0)
+ * @param keepdims - If true, reduced axes are left as dimensions with size 1
+ * @returns Standard deviation value(s)
+ */
+export declare function nanstd(a: NDArray, axis?: number, ddof?: number, keepdims?: boolean): NDArray | number;
+/**
+ * Return minimum of an array, ignoring NaNs.
+ * @param a - Input array
+ * @param axis - Axis along which to compute. If undefined, use all elements.
+ * @param keepdims - If true, reduced axes are left as dimensions with size 1
+ * @returns Minimum value(s)
+ */
+export declare function nanmin(a: NDArray, axis?: number, keepdims?: boolean): NDArray | number;
+/**
+ * Return maximum of an array, ignoring NaNs.
+ * @param a - Input array
+ * @param axis - Axis along which to compute. If undefined, use all elements.
+ * @param keepdims - If true, reduced axes are left as dimensions with size 1
+ * @returns Maximum value(s)
+ */
+export declare function nanmax(a: NDArray, axis?: number, keepdims?: boolean): NDArray | number;
+/**
+ * Return indices of the minimum value, ignoring NaNs.
+ * @param a - Input array
+ * @param axis - Axis along which to compute. If undefined, use flattened array.
+ * @returns Index/indices of minimum value(s)
+ */
+export declare function nanargmin(a: NDArray, axis?: number): NDArray | number;
+/**
+ * Return indices of the maximum value, ignoring NaNs.
+ * @param a - Input array
+ * @param axis - Axis along which to compute. If undefined, use flattened array.
+ * @returns Index/indices of maximum value(s)
+ */
+export declare function nanargmax(a: NDArray, axis?: number): NDArray | number;
+/**
+ * Return cumulative sum of elements, treating NaNs as zero.
+ * @param a - Input array
+ * @param axis - Axis along which to compute. If undefined, use flattened array.
+ * @returns Array with cumulative sums
+ */
+export declare function nancumsum(a: NDArray, axis?: number): NDArray;
+/**
+ * Return cumulative product of elements, treating NaNs as one.
+ * @param a - Input array
+ * @param axis - Axis along which to compute. If undefined, use flattened array.
+ * @returns Array with cumulative products
+ */
+export declare function nancumprod(a: NDArray, axis?: number): NDArray;
+/**
+ * Compute the median, ignoring NaNs.
+ * @param a - Input array
+ * @param axis - Axis along which to compute. If undefined, use all elements.
+ * @param keepdims - If true, reduced axes are left as dimensions with size 1
+ * @returns Median value(s)
+ */
+export declare function nanmedian(a: NDArray, axis?: number, keepdims?: boolean): NDArray | number;
+/**
+ * Element-wise cube root
+ *
+ * @param x - Input array
+ * @returns Array with cube root of each element
+ */
+export declare function cbrt(x: NDArray): NDArray;
+/**
+ * Element-wise absolute value (always returns float)
+ *
+ * @param x - Input array
+ * @returns Array with absolute values as float
+ */
+export declare function fabs(x: NDArray): NDArray;
+/**
+ * Returns both quotient and remainder (floor divide and modulo)
+ *
+ * @param x - Dividend array
+ * @param y - Divisor (array or scalar)
+ * @returns Tuple of [quotient, remainder] arrays
+ */
+export declare function divmod(x: NDArray, y: NDArray | number): [NDArray, NDArray];
+/**
+ * Element-wise square (x**2)
+ *
+ * @param x - Input array
+ * @returns Array with squared values
+ */
+export declare function square(x: NDArray): NDArray;
+/**
+ * Element-wise remainder (same as mod)
+ *
+ * @param x - Dividend array
+ * @param y - Divisor (array or scalar)
+ * @returns Array with remainder values
+ */
+export declare function remainder(x: NDArray, y: NDArray | number): NDArray;
+/**
+ * Heaviside step function
+ *
+ * @param x1 - Input array
+ * @param x2 - Value to use when x1 is 0
+ * @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
+ *
+ * Performs tensor contractions and reductions using Einstein notation.
+ *
+ * @param subscripts - Einstein summation subscripts (e.g., 'ij,jk->ik')
+ * @param operands - Input arrays
+ * @returns Result of the Einstein summation
+ *
+ * @example
+ * // Matrix multiplication
+ * einsum('ij,jk->ik', a, b)
+ *
+ * @example
+ * // Inner product
+ * einsum('i,i->', a, b)
+ *
+ * @example
+ * // Trace
+ * 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