numpy-ts 0.9.0 → 0.11.0

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

@@ -4,6 +4,7 @@
  * Core array class providing NumPy-like API
  */
 import { type DType, type TypedArray } from './dtype';
+import { Complex } from './complex';
 import { ArrayStorage } from './storage';
 export declare class NDArray {
     private _storage;
@@ -39,18 +40,44 @@ export declare class NDArray {
      * Similar to NumPy's base attribute
      */
     get base(): NDArray | null;
+    /**
+     * Transpose of the array (shorthand for transpose())
+     * Returns a view with axes reversed
+     */
+    get T(): NDArray;
+    /**
+     * Size of one array element in bytes
+     */
+    get itemsize(): number;
+    /**
+     * Total bytes consumed by the elements of the array
+     */
+    get nbytes(): number;
+    /**
+     * Fill the array with a scalar value (in-place)
+     * @param value - Value to fill with
+     */
+    fill(value: number | bigint): void;
+    /**
+     * Iterator protocol - iterate over the first axis
+     * For 1D arrays, yields elements; for ND arrays, yields (N-1)D subarrays
+     */
+    [Symbol.iterator](): Iterator<NDArray | number | bigint | Complex>;
     /**
      * Get a single element from the array
      * @param indices - Array of indices, one per dimension (e.g., [0, 1] for 2D array)
-     * @returns The element value (BigInt for int64/uint64, number otherwise)
+     * @returns The element value (BigInt for int64/uint64, Complex for complex, number otherwise)
      */
-    get(indices: number[]): number | bigint;
+    get(indices: number[]): number | bigint | Complex;
     /**
      * Set a single element in the array
      * @param indices - Array of indices, one per dimension (e.g., [0, 1] for 2D array)
      * @param value - Value to set (will be converted to array's dtype)
      */
-    set(indices: number[], value: number | bigint): void;
+    set(indices: number[], value: number | bigint | Complex | {
+        re: number;
+        im: number;
+    }): void;
     /**
      * Return a deep copy of the array
      */
@@ -421,13 +448,78 @@ export declare class NDArray {
      * @returns Result of right shift
      */
     right_shift(shift: NDArray | number): NDArray;
+    /**
+     * Logical AND element-wise
+     * @param other - Array or scalar for AND operation
+     * @returns Boolean array (1 = true, 0 = false)
+     */
+    logical_and(other: NDArray | number): NDArray;
+    /**
+     * Logical OR element-wise
+     * @param other - Array or scalar for OR operation
+     * @returns Boolean array (1 = true, 0 = false)
+     */
+    logical_or(other: NDArray | number): NDArray;
+    /**
+     * Logical NOT element-wise
+     * @returns Boolean array (1 = true, 0 = false)
+     */
+    logical_not(): NDArray;
+    /**
+     * Logical XOR element-wise
+     * @param other - Array or scalar for XOR operation
+     * @returns Boolean array (1 = true, 0 = false)
+     */
+    logical_xor(other: NDArray | number): NDArray;
+    /**
+     * Test element-wise for finiteness (not infinity and not NaN)
+     * @returns Boolean array
+     */
+    isfinite(): NDArray;
+    /**
+     * Test element-wise for positive or negative infinity
+     * @returns Boolean array
+     */
+    isinf(): NDArray;
+    /**
+     * Test element-wise for NaN (Not a Number)
+     * @returns Boolean array
+     */
+    isnan(): NDArray;
+    /**
+     * Test element-wise for NaT (Not a Time)
+     * @returns Boolean array (always false without datetime support)
+     */
+    isnat(): NDArray;
+    /**
+     * Change the sign of x1 to that of x2, element-wise
+     * @param x2 - Values whose sign is used
+     * @returns Array with magnitude from this and sign from x2
+     */
+    copysign(x2: NDArray | number): NDArray;
+    /**
+     * Returns element-wise True where signbit is set (less than zero)
+     * @returns Boolean array
+     */
+    signbit(): NDArray;
+    /**
+     * Return the next floating-point value after x1 towards x2, element-wise
+     * @param x2 - Direction to look for the next representable value
+     * @returns Array of next representable values
+     */
+    nextafter(x2: NDArray | number): NDArray;
+    /**
+     * Return the distance between x and the nearest adjacent number
+     * @returns Array of spacing values
+     */
+    spacing(): NDArray;
     /**
      * Sum array elements over a given axis
      * @param axis - Axis along which to sum. If undefined, sum all elements
      * @param keepdims - If true, reduced axes are left as dimensions with size 1
      * @returns Sum of array elements, or array of sums along axis
      */
-    sum(axis?: number, keepdims?: boolean): NDArray | number;
+    sum(axis?: number, keepdims?: boolean): NDArray | number | Complex;
     /**
      * Compute the arithmetic mean along the specified axis
      * @param axis - Axis along which to compute mean. If undefined, compute mean of all elements
@@ -436,28 +528,28 @@ export declare class NDArray {
      *
      * Note: mean() returns float64 for integer dtypes, matching NumPy behavior
      */
-    mean(axis?: number, keepdims?: boolean): NDArray | number;
+    mean(axis?: number, keepdims?: boolean): NDArray | number | Complex;
     /**
      * Return the maximum along a given axis
      * @param axis - Axis along which to compute maximum. If undefined, compute maximum of all elements
      * @param keepdims - If true, reduced axes are left as dimensions with size 1
      * @returns Maximum of array elements, or array of maximums along axis
      */
-    max(axis?: number, keepdims?: boolean): NDArray | number;
+    max(axis?: number, keepdims?: boolean): NDArray | number | Complex;
     /**
      * Return the minimum along a given axis
      * @param axis - Axis along which to compute minimum. If undefined, compute minimum of all elements
      * @param keepdims - If true, reduced axes are left as dimensions with size 1
      * @returns Minimum of array elements, or array of minimums along axis
      */
-    min(axis?: number, keepdims?: boolean): NDArray | number;
+    min(axis?: number, keepdims?: boolean): NDArray | number | Complex;
     /**
      * Product of array elements over a given axis
      * @param axis - Axis along which to compute the product. If undefined, product of all elements.
      * @param keepdims - If true, reduced axes are left as dimensions with size 1
      * @returns Product of array elements, or array of products along axis
      */
-    prod(axis?: number, keepdims?: boolean): NDArray | number;
+    prod(axis?: number, keepdims?: boolean): NDArray | number | Complex;
     /**
      * Indices of the minimum values along an axis
      * @param axis - Axis along which to find minimum indices. If undefined, index of global minimum.
@@ -518,7 +610,7 @@ export declare class NDArray {
      * @param keepdims - If true, reduced axes are left as dimensions with size 1
      * @returns Range of values
      */
-    ptp(axis?: number, keepdims?: boolean): NDArray | number;
+    ptp(axis?: number, keepdims?: boolean): NDArray | number | Complex;
     /**
      * Compute the median along the specified axis
      * @param axis - Axis along which to compute median. If undefined, compute over all elements.
@@ -548,28 +640,28 @@ export declare class NDArray {
      * @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;
+    average(weights?: NDArray, axis?: number): NDArray | number | Complex;
     /**
      * 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;
+    nansum(axis?: number, keepdims?: boolean): NDArray | number | Complex;
     /**
      * 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;
+    nanprod(axis?: number, keepdims?: boolean): NDArray | number | Complex;
     /**
      * 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;
+    nanmean(axis?: number, keepdims?: boolean): NDArray | number | Complex;
     /**
      * Compute the variance, ignoring NaNs
      * @param axis - Axis along which to compute variance. If undefined, compute over all elements.
@@ -592,14 +684,14 @@ export declare class NDArray {
      * @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;
+    nanmin(axis?: number, keepdims?: boolean): NDArray | number | Complex;
     /**
      * 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;
+    nanmax(axis?: number, keepdims?: boolean): NDArray | number | Complex;
     /**
      * Return the indices of the minimum values, ignoring NaNs
      * @param axis - Axis along which to find minimum indices. If undefined, index of global minimum.
@@ -662,6 +754,12 @@ export declare class NDArray {
      * @returns Tuple of arrays, one for each dimension
      */
     nonzero(): NDArray[];
+    /**
+     * Find the indices of array elements that are non-zero, grouped by element
+     * Returns a 2D array where each row is the index of a non-zero element.
+     * @returns 2D array of shape (N, ndim) where N is number of non-zero elements
+     */
+    argwhere(): NDArray;
     /**
      * Find indices where elements should be inserted to maintain order
      * @param v - Values to insert
@@ -745,6 +843,56 @@ export declare class NDArray {
      * @param values - Values to put
      */
     put(indices: number[], values: NDArray | number | bigint): void;
+    /**
+     * Integer array indexing (fancy indexing)
+     *
+     * Select elements using an array of indices. This is NumPy's "fancy indexing"
+     * feature: `arr[[0, 2, 4]]` becomes `arr.iindex([0, 2, 4])` or `arr.iindex(indices)`.
+     *
+     * @param indices - Array of integer indices (as number[], NDArray, or nested arrays)
+     * @param axis - Axis along which to index (default: 0, or flattens if undefined with flat indices)
+     * @returns New array with selected elements
+     *
+     * @example
+     * ```typescript
+     * const arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]);
+     *
+     * // Select rows 0 and 2
+     * arr.iindex([0, 2]);           // [[1, 2, 3], [7, 8, 9]]
+     *
+     * // Select along axis 1 (columns)
+     * arr.iindex([0, 2], 1);        // [[1, 3], [4, 6], [7, 9]]
+     *
+     * // With NDArray indices
+     * const idx = np.array([0, 2]);
+     * arr.iindex(idx);              // [[1, 2, 3], [7, 8, 9]]
+     * ```
+     */
+    iindex(indices: NDArray | number[] | number[][], axis?: number): NDArray;
+    /**
+     * Boolean array indexing (fancy indexing with mask)
+     *
+     * Select elements where a boolean mask is true. This is NumPy's boolean
+     * indexing: `arr[arr > 5]` becomes `arr.bindex(arr.greater(5))`.
+     *
+     * @param mask - Boolean NDArray mask
+     * @param axis - Axis along which to apply the mask (default: flattens array)
+     * @returns New 1D array with selected elements (or along axis if specified)
+     *
+     * @example
+     * ```typescript
+     * const arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]);
+     *
+     * // Select all elements > 5
+     * const mask = arr.greater(5);
+     * arr.bindex(mask);             // [6, 7, 8, 9]
+     *
+     * // Select rows where first column > 3
+     * const rowMask = np.array([false, true, true]);
+     * arr.bindex(rowMask, 0);       // [[4, 5, 6], [7, 8, 9]]
+     * ```
+     */
+    bindex(mask: NDArray, axis?: number): NDArray;
     /**
      * Matrix multiplication
      * @param other - Array to multiply with
@@ -754,20 +902,20 @@ export declare class NDArray {
     /**
      * Dot product (matching NumPy behavior)
      * @param other - Array to dot with
-     * @returns Result of dot product (scalar or array depending on dimensions)
+     * @returns Result of dot product (scalar or array depending on dimensions, Complex for complex arrays)
      */
-    dot(other: NDArray): NDArray | number | bigint;
+    dot(other: NDArray): NDArray | number | bigint | Complex;
     /**
      * Sum of diagonal elements (trace)
-     * @returns Sum of diagonal elements
+     * @returns Sum of diagonal elements (Complex for complex arrays)
      */
-    trace(): number | bigint;
+    trace(): number | bigint | Complex;
     /**
      * Inner product (contracts over last axes of both arrays)
      * @param other - Array to compute inner product with
-     * @returns Inner product result
+     * @returns Inner product result (Complex for complex arrays)
      */
-    inner(other: NDArray): NDArray | number | bigint;
+    inner(other: NDArray): NDArray | number | bigint | Complex;
     /**
      * Outer product (flattens inputs then computes a[i]*b[j])
      * @param other - Array to compute outer product with
@@ -780,7 +928,7 @@ export declare class NDArray {
      * @param axes - Axes to contract (integer or [a_axes, b_axes])
      * @returns Tensor dot product result
      */
-    tensordot(other: NDArray, axes?: number | [number[], number[]]): NDArray | number | bigint;
+    tensordot(other: NDArray, axes?: number | [number[], number[]]): NDArray | number | bigint | Complex;
     /**
      * Element-wise cube root
      * Promotes integer types to float64
@@ -1131,6 +1279,7 @@ export declare function sqrt(x: NDArray): NDArray;
  * @returns Array of x raised to exponent
  */
 export declare function power(x: NDArray, exponent: NDArray | number): NDArray;
+export { power as pow };
 /**
  * Element-wise natural exponential (e^x)
  * @param x - Input array
@@ -1197,6 +1346,7 @@ export declare function logaddexp2(x1: NDArray, x2: NDArray | number): NDArray;
  * @returns Array of absolute values
  */
 export declare function absolute(x: NDArray): NDArray;
+export { absolute as abs };
 /**
  * Element-wise negation
  * @param x - Input array
@@ -1216,6 +1366,14 @@ export declare function sign(x: NDArray): NDArray;
  * @returns Remainder after division
  */
 export declare function mod(x: NDArray, divisor: NDArray | number): NDArray;
+/**
+ * Element-wise division
+ * @param x - Dividend array
+ * @param divisor - Divisor (array or scalar)
+ * @returns Array of quotients
+ */
+export declare function divide(x: NDArray, divisor: NDArray | number): NDArray;
+export { divide as true_divide };
 /**
  * Element-wise floor division
  * @param x - Dividend array
@@ -1251,16 +1409,16 @@ export declare function reciprocal(x: NDArray): NDArray;
  *
  * @param a - First array
  * @param b - Second array
- * @returns Result of dot product
+ * @returns Result of dot product (Complex for complex arrays)
  */
-export declare function dot(a: NDArray, b: NDArray): NDArray | number | bigint;
+export declare function dot(a: NDArray, b: NDArray): NDArray | number | bigint | Complex;
 /**
  * Sum of diagonal elements
  *
  * @param a - Input 2D array
- * @returns Sum of diagonal elements
+ * @returns Sum of diagonal elements (Complex for complex arrays)
  */
-export declare function trace(a: NDArray): number | bigint;
+export declare function trace(a: NDArray): number | bigint | Complex;
 /**
  * Extract a diagonal from a matrix or N-D array
  *
@@ -1295,9 +1453,9 @@ export declare function transpose(a: NDArray, axes?: number[]): NDArray;
  *
  * @param a - First array
  * @param b - Second array
- * @returns Inner product result
+ * @returns Inner product result (Complex for complex arrays)
  */
-export declare function inner(a: NDArray, b: NDArray): NDArray | number | bigint;
+export declare function inner(a: NDArray, b: NDArray): NDArray | number | bigint | Complex;
 /**
  * Outer product of two arrays
  *
@@ -1316,7 +1474,7 @@ export declare function outer(a: NDArray, b: NDArray): NDArray;
  * @param axes - Axes to contract (integer or [a_axes, b_axes])
  * @returns Tensor dot product
  */
-export declare function tensordot(a: NDArray, b: NDArray, axes?: number | [number[], number[]]): NDArray | number | bigint;
+export declare function tensordot(a: NDArray, b: NDArray, axes?: number | [number[], number[]]): NDArray | number | bigint | Complex;
 /**
  * Element-wise sine
  * @param x - Input array (angles in radians)
@@ -1341,18 +1499,21 @@ export declare function tan(x: NDArray): NDArray;
  * @returns Array of angles in radians
  */
 export declare function arcsin(x: NDArray): NDArray;
+export { arcsin as asin };
 /**
  * Element-wise inverse cosine
  * @param x - Input array (values in range [-1, 1])
  * @returns Array of angles in radians
  */
 export declare function arccos(x: NDArray): NDArray;
+export { arccos as acos };
 /**
  * Element-wise inverse tangent
  * @param x - Input array
  * @returns Array of angles in radians
  */
 export declare function arctan(x: NDArray): NDArray;
+export { arctan as atan };
 /**
  * Element-wise arc tangent of x1/x2 choosing the quadrant correctly
  * @param x1 - y-coordinates
@@ -1360,6 +1521,7 @@ export declare function arctan(x: NDArray): NDArray;
  * @returns Angles in radians between -π and π
  */
 export declare function arctan2(x1: NDArray, x2: NDArray | number): NDArray;
+export { arctan2 as atan2 };
 /**
  * Given the "legs" of a right triangle, return its hypotenuse
  * Equivalent to sqrt(x1**2 + x2**2), element-wise
@@ -1416,18 +1578,21 @@ export declare function tanh(x: NDArray): NDArray;
  * @returns Array of arcsinh values
  */
 export declare function arcsinh(x: NDArray): NDArray;
+export { arcsinh as asinh };
 /**
  * Element-wise inverse hyperbolic cosine
  * @param x - Input array (values >= 1)
  * @returns Array of arccosh values
  */
 export declare function arccosh(x: NDArray): NDArray;
+export { arccosh as acosh };
 /**
  * Element-wise inverse hyperbolic tangent
  * @param x - Input array (values in range (-1, 1))
  * @returns Array of arctanh values
  */
 export declare function arctanh(x: NDArray): NDArray;
+export { arctanh as atanh };
 /**
  * Swap two axes of an array
  *
@@ -1746,6 +1911,60 @@ export declare function take(a: NDArray, indices: number[], axis?: number): NDAr
  * @param values - Values to put
  */
 export declare function put(a: NDArray, indices: number[], values: NDArray | number | bigint): void;
+/**
+ * Integer array indexing (fancy indexing)
+ *
+ * Select elements from an array using an array of indices.
+ * NumPy equivalent: `arr[[0, 2, 4]]`
+ *
+ * @param a - Input array
+ * @param indices - Array of integer indices (as number[], NDArray, or nested arrays)
+ * @param axis - Axis along which to index (default: 0)
+ * @returns New array with selected elements
+ *
+ * @example
+ * ```typescript
+ * const arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]);
+ * np.iindex(arr, [0, 2]);      // [[1, 2, 3], [7, 8, 9]]
+ * np.iindex(arr, [0, 2], 1);   // [[1, 3], [4, 6], [7, 9]]
+ * ```
+ */
+export declare function iindex(a: NDArray, indices: NDArray | number[] | number[][], axis?: number): NDArray;
+/**
+ * Boolean array indexing (fancy indexing with mask)
+ *
+ * Select elements from an array where a boolean mask is true.
+ * NumPy equivalent: `arr[arr > 5]`
+ *
+ * @param a - Input array
+ * @param mask - Boolean NDArray mask
+ * @param axis - Axis along which to apply the mask (default: flattens array)
+ * @returns New array with selected elements
+ *
+ * @example
+ * ```typescript
+ * const arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]);
+ * const mask = arr.greater(5);
+ * np.bindex(arr, mask);        // [6, 7, 8, 9]
+ * ```
+ */
+export declare function bindex(a: NDArray, mask: NDArray, axis?: number): NDArray;
+/**
+ * Copy values from one array to another, broadcasting as necessary.
+ *
+ * @param dst - Destination array (modified in-place)
+ * @param src - Source array or scalar
+ * @param where - Optional boolean array. Only copy where True (not yet implemented)
+ * @throws Error if shapes are not broadcastable
+ *
+ * @example
+ * ```typescript
+ * const dst = np.zeros([3, 3]);
+ * const src = np.array([1, 2, 3]);
+ * np.copyto(dst, src);  // Each row of dst becomes [1, 2, 3]
+ * ```
+ */
+export declare function copyto(dst: NDArray, src: NDArray | number | bigint, where?: NDArray): void;
 /**
  * Construct array from index array and choices
  *
@@ -1779,6 +1998,7 @@ export declare function array_equiv(a1: NDArray, a2: NDArray): boolean;
  * @returns Array with cumulative sums
  */
 export declare function cumsum(a: NDArray, axis?: number): NDArray;
+export { cumsum as cumulative_sum };
 /**
  * Return the cumulative product of the elements along a given axis.
  * @param a - Input array
@@ -1786,6 +2006,25 @@ export declare function cumsum(a: NDArray, axis?: number): NDArray;
  * @returns Array with cumulative products
  */
 export declare function cumprod(a: NDArray, axis?: number): NDArray;
+export { cumprod as cumulative_prod };
+/**
+ * Return the maximum 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 Maximum value(s)
+ */
+export declare function max(a: NDArray, axis?: number, keepdims?: boolean): NDArray | number | Complex;
+export { max as amax };
+/**
+ * Return the minimum 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 Minimum value(s)
+ */
+export declare function min(a: NDArray, axis?: number, keepdims?: boolean): NDArray | number | Complex;
+export { min as amin };
 /**
  * Peak to peak (maximum - minimum) value along a given axis.
  * @param a - Input array
@@ -1793,7 +2032,7 @@ export declare function cumprod(a: NDArray, axis?: number): NDArray;
  * @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;
+export declare function ptp(a: NDArray, axis?: number, keepdims?: boolean): NDArray | number | Complex;
 /**
  * Compute the median along the specified axis.
  * @param a - Input array
@@ -1828,7 +2067,7 @@ export declare function quantile(a: NDArray, q: number, axis?: number, keepdims?
  * @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;
+export declare function average(a: NDArray, axis?: number, weights?: NDArray, keepdims?: boolean): NDArray | number | Complex;
 /**
  * Return the sum of array elements over a given axis, treating NaNs as zero.
  * @param a - Input array
@@ -1836,7 +2075,7 @@ export declare function average(a: NDArray, axis?: number, weights?: NDArray, ke
  * @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;
+export declare function nansum(a: NDArray, axis?: number, keepdims?: boolean): NDArray | number | Complex;
 /**
  * Return the product of array elements over a given axis, treating NaNs as one.
  * @param a - Input array
@@ -1844,7 +2083,7 @@ export declare function nansum(a: NDArray, axis?: number, keepdims?: boolean): N
  * @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;
+export declare function nanprod(a: NDArray, axis?: number, keepdims?: boolean): NDArray | number | Complex;
 /**
  * Compute the arithmetic mean along the specified axis, ignoring NaNs.
  * @param a - Input array
@@ -1852,7 +2091,7 @@ export declare function nanprod(a: NDArray, axis?: number, keepdims?: boolean):
  * @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;
+export declare function nanmean(a: NDArray, axis?: number, keepdims?: boolean): NDArray | number | Complex;
 /**
  * Compute the variance along the specified axis, ignoring NaNs.
  * @param a - Input array
@@ -1878,7 +2117,7 @@ export declare function nanstd(a: NDArray, axis?: number, ddof?: number, keepdim
  * @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;
+export declare function nanmin(a: NDArray, axis?: number, keepdims?: boolean): NDArray | number | Complex;
 /**
  * Return maximum of an array, ignoring NaNs.
  * @param a - Input array
@@ -1886,7 +2125,7 @@ export declare function nanmin(a: NDArray, axis?: number, keepdims?: boolean): N
  * @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;
+export declare function nanmax(a: NDArray, axis?: number, keepdims?: boolean): NDArray | number | Complex;
 /**
  * Return indices of the minimum value, ignoring NaNs.
  * @param a - Input array
@@ -1968,6 +2207,55 @@ 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;
+/**
+ * First array raised to power of second, always promoting to float
+ * @param x1 - Base values
+ * @param x2 - Exponent values
+ * @returns Result in float64
+ */
+export declare function float_power(x1: NDArray, x2: NDArray | number): NDArray;
+/**
+ * Element-wise remainder of division (fmod)
+ * Unlike mod/remainder, fmod matches C fmod behavior
+ * @param x1 - Dividend
+ * @param x2 - Divisor
+ * @returns Remainder
+ */
+export declare function fmod(x1: NDArray, x2: NDArray | number): NDArray;
+/**
+ * Decompose floating point numbers into mantissa and exponent
+ * Returns [mantissa, exponent] where x = mantissa * 2^exponent
+ * @param x - Input array
+ * @returns Tuple of [mantissa, exponent] arrays
+ */
+export declare function frexp(x: NDArray): [NDArray, NDArray];
+/**
+ * Greatest common divisor
+ * @param x1 - First array
+ * @param x2 - Second array or scalar
+ * @returns GCD
+ */
+export declare function gcd(x1: NDArray, x2: NDArray | number): NDArray;
+/**
+ * Least common multiple
+ * @param x1 - First array
+ * @param x2 - Second array or scalar
+ * @returns LCM
+ */
+export declare function lcm(x1: NDArray, x2: NDArray | number): NDArray;
+/**
+ * Returns x1 * 2^x2, element-wise
+ * @param x1 - Mantissa
+ * @param x2 - Exponent
+ * @returns Result
+ */
+export declare function ldexp(x1: NDArray, x2: NDArray | number): NDArray;
+/**
+ * Return fractional and integral parts of array
+ * @param x - Input array
+ * @returns Tuple of [fractional, integral] arrays
+ */
+export declare function modf(x: NDArray): [NDArray, NDArray];
 /**
  * Bitwise AND element-wise
  *
@@ -2046,6 +2334,238 @@ export declare function packbits(a: NDArray, axis?: number, bitorder?: 'big' | '
  * @returns Unpacked uint8 array of 0s and 1s
  */
 export declare function unpackbits(a: NDArray, axis?: number, count?: number, bitorder?: 'big' | 'little'): NDArray;
+/**
+ * Logical AND element-wise
+ *
+ * Returns a boolean array where each element is the logical AND
+ * of corresponding elements (non-zero = true, zero = false).
+ *
+ * @param x1 - First input array
+ * @param x2 - Second input array or scalar
+ * @returns Boolean result array
+ */
+export declare function logical_and(x1: NDArray, x2: NDArray | number): NDArray;
+/**
+ * Logical OR element-wise
+ *
+ * Returns a boolean array where each element is the logical OR
+ * of corresponding elements (non-zero = true, zero = false).
+ *
+ * @param x1 - First input array
+ * @param x2 - Second input array or scalar
+ * @returns Boolean result array
+ */
+export declare function logical_or(x1: NDArray, x2: NDArray | number): NDArray;
+/**
+ * Logical NOT element-wise
+ *
+ * Returns a boolean array where each element is the logical NOT
+ * of the input (non-zero = false, zero = true).
+ *
+ * @param x - Input array
+ * @returns Boolean result array
+ */
+export declare function logical_not(x: NDArray): NDArray;
+/**
+ * Logical XOR element-wise
+ *
+ * Returns a boolean array where each element is the logical XOR
+ * of corresponding elements (non-zero = true, zero = false).
+ *
+ * @param x1 - First input array
+ * @param x2 - Second input array or scalar
+ * @returns Boolean result array
+ */
+export declare function logical_xor(x1: NDArray, x2: NDArray | number): NDArray;
+/**
+ * Test element-wise for finiteness (not infinity and not NaN)
+ *
+ * @param x - Input array
+ * @returns Boolean array where True means finite
+ */
+export declare function isfinite(x: NDArray): NDArray;
+/**
+ * Test element-wise for positive or negative infinity
+ *
+ * @param x - Input array
+ * @returns Boolean array where True means infinite
+ */
+export declare function isinf(x: NDArray): NDArray;
+/**
+ * Test element-wise for NaN (Not a Number)
+ *
+ * @param x - Input array
+ * @returns Boolean array where True means NaN
+ */
+export declare function isnan(x: NDArray): NDArray;
+/**
+ * Test element-wise for NaT (Not a Time)
+ *
+ * @param x - Input array
+ * @returns Boolean array (always false without datetime support)
+ */
+export declare function isnat(x: NDArray): NDArray;
+/**
+ * Change the sign of x1 to that of x2, element-wise
+ *
+ * Returns a value with the magnitude of x1 and the sign of x2.
+ *
+ * @param x1 - Values to change sign of (magnitude source)
+ * @param x2 - Values whose sign is used (sign source)
+ * @returns Array with magnitude from x1 and sign from x2
+ */
+export declare function copysign(x1: NDArray, x2: NDArray | number): NDArray;
+/**
+ * Returns element-wise True where signbit is set (less than zero)
+ *
+ * @param x - Input array
+ * @returns Boolean array where True means signbit is set
+ */
+export declare function signbit(x: NDArray): NDArray;
+/**
+ * Return the next floating-point value after x1 towards x2, element-wise
+ *
+ * @param x1 - Values to find the next representable value of
+ * @param x2 - Direction to look for the next representable value
+ * @returns Array of next representable values
+ */
+export declare function nextafter(x1: NDArray, x2: NDArray | number): NDArray;
+/**
+ * Return the distance between x and the nearest adjacent number
+ *
+ * @param x - Input array
+ * @returns Array of spacing values
+ */
+export declare function spacing(x: NDArray): NDArray;
+/**
+ * Test element-wise for complex number.
+ *
+ * For complex arrays, returns true for elements with non-zero imaginary part.
+ * For real arrays, always returns false.
+ *
+ * @param x - Input array
+ * @returns Boolean array
+ */
+export declare function iscomplex(x: NDArray): NDArray;
+/**
+ * Check whether array is complex type.
+ *
+ * @param x - Input array
+ * @returns true if dtype is complex64 or complex128
+ */
+export declare function iscomplexobj(x: NDArray): boolean;
+/**
+ * Test element-wise for real number (not complex).
+ *
+ * For complex arrays, returns true for elements with zero imaginary part.
+ * For real arrays, always returns true.
+ *
+ * @param x - Input array
+ * @returns Boolean array
+ */
+export declare function isreal(x: NDArray): NDArray;
+/**
+ * Check whether array is real type (not complex).
+ *
+ * @param x - Input array
+ * @returns true if dtype is NOT complex64 or complex128
+ */
+export declare function isrealobj(x: NDArray): boolean;
+/**
+ * Return the real part of complex argument.
+ *
+ * For complex arrays, returns the real components.
+ * For real arrays, returns a copy of the input.
+ *
+ * @param x - Input array
+ * @returns Array with real parts
+ */
+export declare function real(x: NDArray): NDArray;
+/**
+ * Return the imaginary part of complex argument.
+ *
+ * For complex arrays, returns the imaginary components.
+ * For real arrays, returns zeros.
+ *
+ * @param x - Input array
+ * @returns Array with imaginary parts
+ */
+export declare function imag(x: NDArray): NDArray;
+/**
+ * Return the complex conjugate.
+ *
+ * For complex arrays, negates the imaginary part: (a + bi) -> (a - bi)
+ * For real arrays, returns a copy of the input.
+ *
+ * @param x - Input array
+ * @returns Complex conjugate array
+ */
+export declare function conj(x: NDArray): NDArray;
+export declare const conjugate: typeof conj;
+/**
+ * Return the angle (phase) of complex argument.
+ *
+ * angle(z) = arctan2(imag(z), real(z))
+ *
+ * For real arrays, returns 0 for positive, pi for negative.
+ *
+ * @param x - Input array
+ * @param deg - Return angle in degrees if true (default: false, returns radians)
+ * @returns Array with angles in radians (or degrees)
+ */
+export declare function angle(x: NDArray, deg?: boolean): NDArray;
+/**
+ * Test element-wise for negative infinity
+ * @param x - Input array
+ * @returns Boolean array
+ */
+export declare function isneginf(x: NDArray): NDArray;
+/**
+ * Test element-wise for positive infinity
+ * @param x - Input array
+ * @returns Boolean array
+ */
+export declare function isposinf(x: NDArray): NDArray;
+/**
+ * Check if array is Fortran contiguous (column-major order)
+ * @param x - Input array
+ * @returns true if F-contiguous
+ */
+export declare function isfortran(x: NDArray): boolean;
+/**
+ * Returns array with complex parts close to zero set to real
+ * Since numpy-ts doesn't support complex numbers, returns copy
+ * @param x - Input array
+ * @param tol - Tolerance
+ * @returns Copy of input array
+ */
+export declare function real_if_close(x: NDArray, tol?: number): NDArray;
+/**
+ * Check if element is a scalar type
+ * @param val - Value to check
+ * @returns true if scalar
+ */
+export declare function isscalar(val: unknown): boolean;
+/**
+ * Check if object is iterable
+ * @param obj - Object to check
+ * @returns true if iterable
+ */
+export declare function iterable(obj: unknown): boolean;
+/**
+ * Check if dtype meets specified criteria
+ * @param dtype - Dtype to check
+ * @param kind - Kind of dtype ('b' bool, 'i' int, 'u' uint, 'f' float)
+ * @returns true if dtype matches kind
+ */
+export declare function isdtype(dtype: DType, kind: string): boolean;
+/**
+ * Find the dtype that can represent both input dtypes
+ * @param dtype1 - First dtype
+ * @param dtype2 - Second dtype
+ * @returns Promoted dtype
+ */
+export declare function promote_types(dtype1: DType, dtype2: DType): DType;
 /**
  * Einstein summation convention
  *
@@ -2067,7 +2587,7 @@ export declare function unpackbits(a: NDArray, axis?: number, count?: number, bi
  * // Trace
  * einsum('ii->', a)
  */
-export declare function einsum(subscripts: string, ...operands: NDArray[]): NDArray | number | bigint;
+export declare function einsum(subscripts: string, ...operands: NDArray[]): NDArray | number | bigint | Complex;
 /**
  * numpy.linalg module - Linear algebra functions
  */
@@ -2222,6 +2742,13 @@ export declare function select(condlist: NDArray[], choicelist: NDArray[], defau
  * @param vals - Values to place where mask is True (cycles if shorter)
  */
 export declare function place(arr: NDArray, mask: NDArray, vals: NDArray): void;
+/**
+ * Fill the main diagonal of a given array (modifies in-place)
+ * @param a - Array (at least 2D)
+ * @param val - Value or array of values to fill diagonal with
+ * @param wrap - Whether to wrap for tall matrices
+ */
+export declare function fill_diagonal(a: NDArray, val: NDArray | number, wrap?: boolean): void;
 /**
  * Return the indices to access the main diagonal of an array.
  *
@@ -2364,6 +2891,14 @@ export declare function sort_complex(a: NDArray): NDArray;
  * @returns Tuple of arrays, one for each dimension
  */
 export declare function nonzero(a: NDArray): NDArray[];
+/**
+ * Find the indices of array elements that are non-zero, grouped by element
+ * Returns a 2D array where each row is the index of a non-zero element.
+ * This is equivalent to transpose(nonzero(a)).
+ * @param a - Input array
+ * @returns 2D array of shape (N, ndim) where N is number of non-zero elements
+ */
+export declare function argwhere(a: NDArray): NDArray;
 /**
  * Return indices of non-zero elements in flattened array
  * @param a - Input array
@@ -2408,6 +2943,7 @@ export declare function count_nonzero(a: NDArray, axis?: number): NDArray | numb
  * @returns Rounded array
  */
 export declare function around(a: NDArray, decimals?: number): NDArray;
+export { around as round_ };
 /**
  * Return the ceiling of the input, element-wise
  * @param x - Input array
@@ -2537,4 +3073,94 @@ export declare function gradient(f: NDArray, varargs?: number | number[], axis?:
  * @returns Cross product array
  */
 export declare function cross(a: NDArray, b: NDArray, axisa?: number, axisb?: number, axisc?: number): NDArray;
+/**
+ * Count number of occurrences of each value in array of non-negative ints.
+ *
+ * @param x - Input array (must contain non-negative integers)
+ * @param weights - Optional weights, same shape as x
+ * @param minlength - Minimum number of bins for output (default: 0)
+ * @returns Array of bin counts
+ */
+export declare function bincount(x: NDArray, weights?: NDArray, minlength?: number): NDArray;
+/**
+ * Return the indices of the bins to which each value in input array belongs.
+ *
+ * @param x - Input array to be binned
+ * @param bins - Array of bins (monotonically increasing or decreasing)
+ * @param right - If true, intervals are closed on the right (default: false)
+ * @returns Array of bin indices
+ */
+export declare function digitize(x: NDArray, bins: NDArray, right?: boolean): NDArray;
+/**
+ * Compute the histogram of a set of data.
+ *
+ * @param a - Input data (flattened if not 1D)
+ * @param bins - Number of bins (default: 10) or array of bin edges
+ * @param range - Lower and upper range of bins
+ * @param density - If true, return probability density function (default: false)
+ * @param weights - Optional weights for each data point
+ * @returns Tuple of [hist, bin_edges]
+ */
+export declare function histogram(a: NDArray, bins?: number | NDArray, range?: [number, number], density?: boolean, weights?: NDArray): [NDArray, NDArray];
+/**
+ * Compute the bi-dimensional histogram of two data samples.
+ *
+ * @param x - Array of x coordinates
+ * @param y - Array of y coordinates (must have same length as x)
+ * @param bins - Number of bins or [nx, ny] or [x_edges, y_edges]
+ * @param range - [[xmin, xmax], [ymin, ymax]]
+ * @param density - If true, return probability density function
+ * @param weights - Optional weights for each data point
+ * @returns Tuple of [hist, x_edges, y_edges]
+ */
+export declare function histogram2d(x: NDArray, y: NDArray, bins?: number | [number, number] | [NDArray, NDArray], range?: [[number, number], [number, number]], density?: boolean, weights?: NDArray): [NDArray, NDArray, NDArray];
+/**
+ * Compute the multidimensional histogram of some data.
+ *
+ * @param sample - Array of shape (N, D) where N is number of samples and D is number of dimensions
+ * @param bins - Number of bins for all axes, or array of bin counts per axis
+ * @param range - Array of [min, max] for each dimension
+ * @param density - If true, return probability density function
+ * @param weights - Optional weights for each sample
+ * @returns Tuple of [hist, edges (array of edge arrays)]
+ */
+export declare function histogramdd(sample: NDArray, bins?: number | number[], range?: [number, number][], density?: boolean, weights?: NDArray): [NDArray, NDArray[]];
+/**
+ * Cross-correlation of two 1-dimensional sequences.
+ *
+ * @param a - First input sequence
+ * @param v - Second input sequence
+ * @param mode - 'full', 'same', or 'valid' (default: 'full')
+ * @returns Cross-correlation of a and v
+ */
+export declare function correlate(a: NDArray, v: NDArray, mode?: 'full' | 'same' | 'valid'): NDArray;
+/**
+ * Discrete, linear convolution of two one-dimensional sequences.
+ *
+ * @param a - First input sequence
+ * @param v - Second input sequence
+ * @param mode - 'full', 'same', or 'valid' (default: 'full')
+ * @returns Convolution of a and v
+ */
+export declare function convolve(a: NDArray, v: NDArray, mode?: 'full' | 'same' | 'valid'): NDArray;
+/**
+ * Estimate a covariance matrix.
+ *
+ * @param m - Input array (1D or 2D). Each row represents a variable, columns are observations.
+ * @param y - Optional second array (for 2 variable case)
+ * @param rowvar - If true, each row is a variable (default: true)
+ * @param bias - If true, use N for normalization; if false, use N-1 (default: false)
+ * @param ddof - Delta degrees of freedom (overrides bias if provided)
+ * @returns Covariance matrix
+ */
+export declare function cov(m: NDArray, y?: NDArray, rowvar?: boolean, bias?: boolean, ddof?: number): NDArray;
+/**
+ * Return Pearson product-moment correlation coefficients.
+ *
+ * @param x - Input array (1D or 2D)
+ * @param y - Optional second array (for 2 variable case)
+ * @param rowvar - If true, each row is a variable (default: true)
+ * @returns Correlation coefficient matrix
+ */
+export declare function corrcoef(x: NDArray, y?: NDArray, rowvar?: boolean): NDArray;
 //# sourceMappingURL=ndarray.d.ts.map