numpy-ts 0.10.0 → 0.11.0

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

@@ -0,0 +1,94 @@
+/**
+ * Complex number class for numpy-ts
+ *
+ * Represents complex numbers in JavaScript, similar to Python's complex type.
+ * Used when converting complex arrays to JavaScript values via toArray().
+ */
+/**
+ * Represents a complex number with real and imaginary parts.
+ *
+ * @example
+ * ```typescript
+ * const z = new Complex(1, 2);  // 1 + 2i
+ * console.log(z.re);  // 1
+ * console.log(z.im);  // 2
+ * console.log(z.toString());  // "(1+2j)"
+ * ```
+ */
+export declare class Complex {
+    /** Real part */
+    readonly re: number;
+    /** Imaginary part */
+    readonly im: number;
+    constructor(re: number, im?: number);
+    /**
+     * Returns the magnitude (absolute value) of the complex number.
+     * |z| = sqrt(re² + im²)
+     */
+    abs(): number;
+    /**
+     * Returns the phase angle (argument) of the complex number in radians.
+     * arg(z) = atan2(im, re)
+     */
+    angle(): number;
+    /**
+     * Returns the complex conjugate.
+     * conj(a + bi) = a - bi
+     */
+    conj(): Complex;
+    /**
+     * Add another complex number or real number.
+     */
+    add(other: Complex | number): Complex;
+    /**
+     * Subtract another complex number or real number.
+     */
+    sub(other: Complex | number): Complex;
+    /**
+     * Multiply by another complex number or real number.
+     * (a + bi)(c + di) = (ac - bd) + (ad + bc)i
+     */
+    mul(other: Complex | number): Complex;
+    /**
+     * Divide by another complex number or real number.
+     * (a + bi) / (c + di) = ((ac + bd) + (bc - ad)i) / (c² + d²)
+     */
+    div(other: Complex | number): Complex;
+    /**
+     * Returns the negation of this complex number.
+     */
+    neg(): Complex;
+    /**
+     * Check equality with another complex number.
+     */
+    equals(other: Complex): boolean;
+    /**
+     * String representation matching NumPy/Python format: "(a+bj)"
+     */
+    toString(): string;
+    /**
+     * Create a Complex from various input formats.
+     * Accepts:
+     * - Complex instance
+     * - {re, im} object
+     * - [re, im] array
+     * - number (creates re + 0i)
+     */
+    static from(value: ComplexInput): Complex;
+    /**
+     * Check if a value is a complex number representation.
+     */
+    static isComplex(value: unknown): value is ComplexInput;
+}
+/**
+ * Input types that can be converted to Complex.
+ */
+export type ComplexInput = Complex | {
+    re: number;
+    im?: number;
+} | [number, number] | number;
+/**
+ * Helper to check if a value looks like a complex number input.
+ */
+export declare function isComplexLike(value: unknown): value is ComplexInput;
+//# sourceMappingURL=complex.d.ts.map

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

@@ -3,6 +3,7 @@
  *
  * Supports NumPy numeric types:
  * - Floating point: float32, float64
+ * - Complex: complex64, complex128
  * - Signed integers: int8, int16, int32, int64
  * - Unsigned integers: uint8, uint16, uint32, uint64
  * - Boolean: bool
@@ -10,7 +11,7 @@
 /**
  * All supported dtypes
  */
-export type DType = 'float64' | 'float32' | 'int64' | 'int32' | 'int16' | 'int8' | 'uint64' | 'uint32' | 'uint16' | 'uint8' | 'bool';
+export type DType = 'float64' | 'float32' | 'complex128' | 'complex64' | 'int64' | 'int32' | 'int16' | 'int8' | 'uint64' | 'uint32' | 'uint16' | 'uint8' | 'bool';
 /**
  * TypedArray types for each dtype
  */
@@ -20,12 +21,16 @@ export type TypedArray = Float64Array | Float32Array | BigInt64Array | Int32Arra
  */
 export declare const DEFAULT_DTYPE: DType;
 /**
- * Get the TypedArray constructor for a given dtype
+ * Get the TypedArray constructor for a given dtype.
+ * For complex types, returns the underlying float array constructor.
+ * complex128 uses Float64Array, complex64 uses Float32Array.
+ * Note: Complex arrays have 2x the physical elements (interleaved real, imag).
  */
 export declare function getTypedArrayConstructor(dtype: DType): TypedArrayConstructor | null;
 type TypedArrayConstructor = Float64ArrayConstructor | Float32ArrayConstructor | BigInt64ArrayConstructor | Int32ArrayConstructor | Int16ArrayConstructor | Int8ArrayConstructor | BigUint64ArrayConstructor | Uint32ArrayConstructor | Uint16ArrayConstructor | Uint8ArrayConstructor;
 /**
- * Get the element size in bytes for a given dtype
+ * Get the element size in bytes for a given dtype.
+ * For complex types, returns the full element size (both real and imag parts).
  */
 export declare function getDTypeSize(dtype: DType): number;
 /**
@@ -40,6 +45,60 @@ export declare function isFloatDType(dtype: DType): boolean;
  * Check if dtype uses BigInt
  */
 export declare function isBigIntDType(dtype: DType): boolean;
+/**
+ * Check if dtype is complex
+ */
+export declare function isComplexDType(dtype: DType): boolean;
+/**
+ * Throw a TypeError if the dtype is complex.
+ * Use this at the start of functions that don't support complex numbers.
+ *
+ * @param dtype - The dtype to check
+ * @param functionName - The name of the function (for error message)
+ * @param reason - Optional reason why complex is not supported
+ * @throws TypeError if dtype is complex
+ *
+ * @example
+ * ```typescript
+ * export function floor(storage: ArrayStorage): ArrayStorage {
+ *   throwIfComplex(storage.dtype, 'floor', 'rounding is not defined for complex numbers');
+ *   // ... rest of implementation
+ * }
+ * ```
+ */
+export declare function throwIfComplex(dtype: DType, functionName: string, reason?: string): void;
+/**
+ * Throw an error if the dtype is complex and the function doesn't yet support it.
+ * Use this for functions that SHOULD support complex but haven't been implemented yet.
+ *
+ * @param dtype - The dtype to check
+ * @param functionName - The name of the function (for error message)
+ * @throws Error if dtype is complex
+ *
+ * @example
+ * ```typescript
+ * export function sin(storage: ArrayStorage): ArrayStorage {
+ *   throwIfComplexNotImplemented(storage.dtype, 'sin');
+ *   // ... existing real-only implementation
+ * }
+ * ```
+ */
+export declare function throwIfComplexNotImplemented(dtype: DType, functionName: string): void;
+/**
+ * Get the underlying float dtype for a complex dtype.
+ * complex128 -> float64, complex64 -> float32
+ */
+export declare function getComplexComponentDType(dtype: DType): 'float64' | 'float32';
+/**
+ * Get the complex dtype for a given float component dtype.
+ * float64 -> complex128, float32 -> complex64
+ */
+export declare function getComplexDType(componentDtype: 'float64' | 'float32'): 'complex128' | 'complex64';
+/**
+ * Check if a value looks like a complex number input.
+ * Accepts: Complex instance, {re, im} object
+ */
+export declare function isComplexLike(value: unknown): boolean;
 /**
  * Infer dtype from JavaScript value
  */

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;
@@ -61,19 +62,22 @@ export declare class NDArray {
      * 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>;
+    [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
      */
@@ -515,7 +519,7 @@ export declare class NDArray {
      * @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
@@ -524,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.
@@ -606,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.
@@ -636,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.
@@ -680,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.
@@ -839,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
@@ -848,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
@@ -874,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
@@ -1355,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
  *
@@ -1399,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
  *
@@ -1420,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)
@@ -1857,6 +1911,44 @@ 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.
  *
@@ -1922,7 +2014,7 @@ export { cumprod as cumulative_prod };
  * @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;
+export declare function max(a: NDArray, axis?: number, keepdims?: boolean): NDArray | number | Complex;
 export { max as amax };
 /**
  * Return the minimum along a given axis.
@@ -1931,7 +2023,7 @@ export { max as amax };
  * @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;
+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.
@@ -1940,7 +2032,7 @@ export { min as amin };
  * @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
@@ -1975,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
@@ -1983,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
@@ -1991,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
@@ -1999,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
@@ -2025,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
@@ -2033,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
@@ -2346,33 +2438,82 @@ export declare function nextafter(x1: NDArray, x2: NDArray | number): NDArray;
  */
 export declare function spacing(x: NDArray): NDArray;
 /**
- * Test element-wise for complex number
- * Since numpy-ts doesn't support complex numbers, always returns false
+ * 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 (all false)
+ * @returns Boolean array
  */
 export declare function iscomplex(x: NDArray): NDArray;
 /**
- * Check whether array is complex type
- * Since numpy-ts doesn't support complex numbers, always returns false
+ * Check whether array is complex type.
+ *
  * @param x - Input array
- * @returns false
+ * @returns true if dtype is complex64 or complex128
  */
 export declare function iscomplexobj(x: NDArray): boolean;
 /**
- * Test element-wise for real number (not complex)
- * Since numpy-ts doesn't support complex numbers, always returns true
+ * 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 (all true)
+ * @returns Boolean array
  */
 export declare function isreal(x: NDArray): NDArray;
 /**
- * Check whether array is real type (not complex)
- * Since numpy-ts doesn't support complex numbers, always returns true
+ * Check whether array is real type (not complex).
+ *
  * @param x - Input array
- * @returns true
+ * @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
@@ -2446,7 +2587,7 @@ export declare function promote_types(dtype1: DType, dtype2: DType): DType;
  * // 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
  */