numpy-ts 0.8.0 → 0.10.0

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

@@ -39,6 +39,29 @@ 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>;
     /**
      * Get a single element from the array
      * @param indices - Array of indices, one per dimension (e.g., [0, 1] for 2D array)
@@ -120,6 +143,66 @@ export declare class NDArray {
      * @returns New array with powered values
      */
     power(exponent: NDArray | number): NDArray;
+    /**
+     * Natural exponential (e^x) of each element
+     * Promotes integer types to float64
+     * @returns New array with exp values
+     */
+    exp(): NDArray;
+    /**
+     * Base-2 exponential (2^x) of each element
+     * Promotes integer types to float64
+     * @returns New array with exp2 values
+     */
+    exp2(): NDArray;
+    /**
+     * Exponential minus one (e^x - 1) of each element
+     * More accurate than exp(x) - 1 for small x
+     * Promotes integer types to float64
+     * @returns New array with expm1 values
+     */
+    expm1(): NDArray;
+    /**
+     * Natural logarithm (ln) of each element
+     * Promotes integer types to float64
+     * @returns New array with log values
+     */
+    log(): NDArray;
+    /**
+     * Base-2 logarithm of each element
+     * Promotes integer types to float64
+     * @returns New array with log2 values
+     */
+    log2(): NDArray;
+    /**
+     * Base-10 logarithm of each element
+     * Promotes integer types to float64
+     * @returns New array with log10 values
+     */
+    log10(): NDArray;
+    /**
+     * Natural logarithm of (1 + x) of each element
+     * More accurate than log(1 + x) for small x
+     * Promotes integer types to float64
+     * @returns New array with log1p values
+     */
+    log1p(): NDArray;
+    /**
+     * Logarithm of the sum of exponentials: log(exp(x1) + exp(x2))
+     * More numerically stable than computing the expression directly
+     * Promotes integer types to float64
+     * @param x2 - Second operand (array or scalar)
+     * @returns New array with logaddexp values
+     */
+    logaddexp(x2: NDArray | number): NDArray;
+    /**
+     * Logarithm base 2 of the sum of exponentials: log2(2^x1 + 2^x2)
+     * More numerically stable than computing the expression directly
+     * Promotes integer types to float64
+     * @param x2 - Second operand (array or scalar)
+     * @returns New array with logaddexp2 values
+     */
+    logaddexp2(x2: NDArray | number): NDArray;
     /**
      * Absolute value of each element
      * @returns New array with absolute values
@@ -135,6 +218,43 @@ export declare class NDArray {
      * @returns New array with signs
      */
     sign(): NDArray;
+    /**
+     * Round an array to the given number of decimals
+     * @param decimals - Number of decimal places to round to (default: 0)
+     * @returns New array with rounded values
+     */
+    around(decimals?: number): NDArray;
+    /**
+     * Round an array to the given number of decimals (alias for around)
+     * @param decimals - Number of decimal places to round to (default: 0)
+     * @returns New array with rounded values
+     */
+    round(decimals?: number): NDArray;
+    /**
+     * Return the ceiling of the input, element-wise
+     * @returns New array with ceiling values
+     */
+    ceil(): NDArray;
+    /**
+     * Round to nearest integer towards zero
+     * @returns New array with values truncated towards zero
+     */
+    fix(): NDArray;
+    /**
+     * Return the floor of the input, element-wise
+     * @returns New array with floor values
+     */
+    floor(): NDArray;
+    /**
+     * Round elements to the nearest integer
+     * @returns New array with rounded integer values
+     */
+    rint(): NDArray;
+    /**
+     * Return the truncated value of the input, element-wise
+     * @returns New array with truncated values
+     */
+    trunc(): NDArray;
     /**
      * Sine of each element (in radians)
      * Promotes integer types to float64
@@ -324,6 +444,71 @@ 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
@@ -565,6 +750,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
@@ -572,6 +763,13 @@ export declare class NDArray {
      * @returns Indices where values should be inserted
      */
     searchsorted(v: NDArray, side?: 'left' | 'right'): NDArray;
+    /**
+     * Calculate the n-th discrete difference along the given axis
+     * @param n - Number of times values are differenced (default: 1)
+     * @param axis - Axis along which to compute difference (default: -1)
+     * @returns Array of differences
+     */
+    diff(n?: number, axis?: number): NDArray;
     /**
      * Reshape array to a new shape
      * Returns a new array with the specified shape
@@ -1027,12 +1225,74 @@ 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
+ * @returns Array of e^x values
+ */
+export declare function exp(x: NDArray): NDArray;
+/**
+ * Element-wise base-2 exponential (2^x)
+ * @param x - Input array
+ * @returns Array of 2^x values
+ */
+export declare function exp2(x: NDArray): NDArray;
+/**
+ * Element-wise exponential minus one (e^x - 1)
+ * More accurate than exp(x) - 1 for small x
+ * @param x - Input array
+ * @returns Array of expm1 values
+ */
+export declare function expm1(x: NDArray): NDArray;
+/**
+ * Element-wise natural logarithm (ln)
+ * @param x - Input array
+ * @returns Array of log values
+ */
+export declare function log(x: NDArray): NDArray;
+/**
+ * Element-wise base-2 logarithm
+ * @param x - Input array
+ * @returns Array of log2 values
+ */
+export declare function log2(x: NDArray): NDArray;
+/**
+ * Element-wise base-10 logarithm
+ * @param x - Input array
+ * @returns Array of log10 values
+ */
+export declare function log10(x: NDArray): NDArray;
+/**
+ * Element-wise natural logarithm of (1 + x)
+ * More accurate than log(1 + x) for small x
+ * @param x - Input array
+ * @returns Array of log1p values
+ */
+export declare function log1p(x: NDArray): NDArray;
+/**
+ * Logarithm of the sum of exponentials: log(exp(x1) + exp(x2))
+ * More numerically stable than computing the expression directly
+ * @param x1 - First input array
+ * @param x2 - Second input array or scalar
+ * @returns Array of logaddexp values
+ */
+export declare function logaddexp(x1: NDArray, x2: NDArray | number): NDArray;
+/**
+ * Logarithm base 2 of the sum of exponentials: log2(2^x1 + 2^x2)
+ * More numerically stable than computing the expression directly
+ * @param x1 - First input array
+ * @param x2 - Second input array or scalar
+ * @returns Array of logaddexp2 values
+ */
+export declare function logaddexp2(x1: NDArray, x2: NDArray | number): NDArray;
 /**
  * Element-wise absolute value
  * @param x - Input array
  * @returns Array of absolute values
  */
 export declare function absolute(x: NDArray): NDArray;
+export { absolute as abs };
 /**
  * Element-wise negation
  * @param x - Input array
@@ -1052,6 +1312,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
@@ -1177,18 +1445,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
@@ -1196,6 +1467,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
@@ -1252,18 +1524,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
  *
@@ -1582,6 +1857,22 @@ 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;
+/**
+ * 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
  *
@@ -1615,6 +1906,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
@@ -1622,6 +1914,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;
+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;
+export { min as amin };
 /**
  * Peak to peak (maximum - minimum) value along a given axis.
  * @param a - Input array
@@ -1804,6 +2115,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
  *
@@ -1882,6 +2242,189 @@ 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
+ * Since numpy-ts doesn't support complex numbers, always returns false
+ * @param x - Input array
+ * @returns Boolean array (all false)
+ */
+export declare function iscomplex(x: NDArray): NDArray;
+/**
+ * Check whether array is complex type
+ * Since numpy-ts doesn't support complex numbers, always returns false
+ * @param x - Input array
+ * @returns false
+ */
+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
+ * @param x - Input array
+ * @returns Boolean array (all true)
+ */
+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
+ * @param x - Input array
+ * @returns true
+ */
+export declare function isrealobj(x: NDArray): boolean;
+/**
+ * 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
  *
@@ -1904,6 +2447,108 @@ export declare function unpackbits(a: NDArray, axis?: number, count?: number, bi
  * einsum('ii->', a)
  */
 export declare function einsum(subscripts: string, ...operands: NDArray[]): NDArray | number | bigint;
+/**
+ * numpy.linalg module - Linear algebra functions
+ */
+export declare const linalg: {
+    /**
+     * Cross product of two vectors.
+     */
+    cross: (a: NDArray, b: NDArray, axisa?: number, axisb?: number, axisc?: number, axis?: number) => NDArray | number;
+    /**
+     * Compute the norm of a vector or matrix.
+     */
+    norm: (x: NDArray, ord?: number | "fro" | "nuc" | null, axis?: number | [number, number] | null, keepdims?: boolean) => NDArray | number;
+    /**
+     * Compute the vector norm.
+     */
+    vector_norm: (x: NDArray, ord?: number, axis?: number | null, keepdims?: boolean) => NDArray | number;
+    /**
+     * Compute the matrix norm.
+     */
+    matrix_norm: (x: NDArray, ord?: number | "fro" | "nuc", keepdims?: boolean) => NDArray | number;
+    /**
+     * QR decomposition.
+     */
+    qr: (a: NDArray, mode?: "reduced" | "complete" | "r" | "raw") => {
+        q: NDArray;
+        r: NDArray;
+    } | NDArray | {
+        h: NDArray;
+        tau: NDArray;
+    };
+    /**
+     * Cholesky decomposition.
+     */
+    cholesky: (a: NDArray, upper?: boolean) => NDArray;
+    /**
+     * Singular Value Decomposition.
+     */
+    svd: (a: NDArray, full_matrices?: boolean, compute_uv?: boolean) => {
+        u: NDArray;
+        s: NDArray;
+        vt: NDArray;
+    } | NDArray;
+    /**
+     * Compute the determinant of a matrix.
+     */
+    det: (a: NDArray) => number;
+    /**
+     * Compute the matrix inverse.
+     */
+    inv: (a: NDArray) => NDArray;
+    /**
+     * Solve a linear system.
+     */
+    solve: (a: NDArray, b: NDArray) => NDArray;
+    /**
+     * Least-squares solution to a linear matrix equation.
+     */
+    lstsq: (a: NDArray, b: NDArray, rcond?: number | null) => {
+        x: NDArray;
+        residuals: NDArray;
+        rank: number;
+        s: NDArray;
+    };
+    /**
+     * Compute the condition number.
+     */
+    cond: (a: NDArray, p?: number | "fro" | "nuc") => number;
+    /**
+     * Compute the matrix rank.
+     */
+    matrix_rank: (a: NDArray, tol?: number) => number;
+    /**
+     * Raise a square matrix to an integer power.
+     */
+    matrix_power: (a: NDArray, n: number) => NDArray;
+    /**
+     * Compute the Moore-Penrose pseudo-inverse.
+     */
+    pinv: (a: NDArray, rcond?: number) => NDArray;
+    /**
+     * Compute eigenvalues and eigenvectors.
+     */
+    eig: (a: NDArray) => {
+        w: NDArray;
+        v: NDArray;
+    };
+    /**
+     * Compute eigenvalues and eigenvectors of a Hermitian matrix.
+     */
+    eigh: (a: NDArray, UPLO?: "L" | "U") => {
+        w: NDArray;
+        v: NDArray;
+    };
+    /**
+     * Compute eigenvalues of a matrix.
+     */
+    eigvals: (a: NDArray) => NDArray;
+    /**
+     * Compute eigenvalues of a Hermitian matrix.
+     */
+    eigvalsh: (a: NDArray, UPLO?: "L" | "U") => NDArray;
+};
 /**
  * Take values from the input array by matching 1d index and data slices along axis.
  *
@@ -1956,6 +2601,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.
  *
@@ -2098,6 +2750,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
@@ -2135,4 +2795,231 @@ export declare function extract(condition: NDArray, a: NDArray): NDArray;
  * @returns Count of non-zero values
  */
 export declare function count_nonzero(a: NDArray, axis?: number): NDArray | number;
+/**
+ * Round an array to the given number of decimals
+ * @param a - Input array
+ * @param decimals - Number of decimal places to round to (default: 0)
+ * @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
+ * @returns Element-wise ceiling
+ */
+export declare function ceil(x: NDArray): NDArray;
+/**
+ * Round to nearest integer towards zero
+ * @param x - Input array
+ * @returns Array with values truncated towards zero
+ */
+export declare function fix(x: NDArray): NDArray;
+/**
+ * Return the floor of the input, element-wise
+ * @param x - Input array
+ * @returns Element-wise floor
+ */
+export declare function floor(x: NDArray): NDArray;
+/**
+ * Round elements of the array to the nearest integer
+ * @param x - Input array
+ * @returns Array with rounded integer values
+ */
+export declare function rint(x: NDArray): NDArray;
+/**
+ * Evenly round to the given number of decimals (alias for around)
+ * @param a - Input array
+ * @param decimals - Number of decimal places to round to (default: 0)
+ * @returns Rounded array
+ */
+export { around as round };
+/**
+ * Return the truncated value of the input, element-wise
+ * @param x - Input array
+ * @returns Element-wise truncated values
+ */
+export declare function trunc(x: NDArray): NDArray;
+/**
+ * Find the unique elements of an array
+ * @param ar - Input array
+ * @param returnIndex - If True, also return the indices of the first occurrences
+ * @param returnInverse - If True, also return the indices to reconstruct the original array
+ * @param returnCounts - If True, also return the number of times each unique value appears
+ * @returns Unique sorted values, and optionally indices/inverse/counts
+ */
+export declare function unique(ar: NDArray, returnIndex?: boolean, returnInverse?: boolean, returnCounts?: boolean): NDArray | {
+    values: NDArray;
+    indices?: NDArray;
+    inverse?: NDArray;
+    counts?: NDArray;
+};
+/**
+ * Test whether each element of a 1-D array is also present in a second array
+ * @param ar1 - Input array
+ * @param ar2 - Test values
+ * @returns Boolean array indicating membership
+ */
+export declare function in1d(ar1: NDArray, ar2: NDArray): NDArray;
+/**
+ * Find the intersection of two arrays
+ * @param ar1 - First input array
+ * @param ar2 - Second input array
+ * @returns Sorted 1D array of common and unique elements
+ */
+export declare function intersect1d(ar1: NDArray, ar2: NDArray): NDArray;
+/**
+ * Test whether each element of an ND array is also present in a second array
+ * @param element - Input array
+ * @param testElements - Test values
+ * @returns Boolean array indicating membership (same shape as element)
+ */
+export declare function isin(element: NDArray, testElements: NDArray): NDArray;
+/**
+ * Find the set difference of two arrays
+ * @param ar1 - First input array
+ * @param ar2 - Second input array
+ * @returns Sorted 1D array of values in ar1 that are not in ar2
+ */
+export declare function setdiff1d(ar1: NDArray, ar2: NDArray): NDArray;
+/**
+ * Find the set exclusive-or of two arrays
+ * @param ar1 - First input array
+ * @param ar2 - Second input array
+ * @returns Sorted 1D array of values that are in only one array
+ */
+export declare function setxor1d(ar1: NDArray, ar2: NDArray): NDArray;
+/**
+ * Find the union of two arrays
+ * @param ar1 - First input array
+ * @param ar2 - Second input array
+ * @returns Sorted 1D array of unique values from both arrays
+ */
+export declare function union1d(ar1: NDArray, ar2: NDArray): NDArray;
+/**
+ * Calculate the n-th discrete difference along the given axis
+ * @param a - Input array
+ * @param n - Number of times values are differenced (default: 1)
+ * @param axis - Axis along which to compute difference (default: -1)
+ * @returns Array of differences
+ */
+export declare function diff(a: NDArray, n?: number, axis?: number): NDArray;
+/**
+ * The differences between consecutive elements of a flattened array
+ * @param ary - Input array
+ * @param to_end - Number(s) to append at the end
+ * @param to_begin - Number(s) to prepend at the beginning
+ * @returns Array of differences
+ */
+export declare function ediff1d(ary: NDArray, to_end?: number[] | null, to_begin?: number[] | null): NDArray;
+/**
+ * Return the gradient of an N-dimensional array
+ * The gradient is computed using second order accurate central differences
+ * in the interior and first order accurate one-sided differences at the boundaries.
+ * @param f - Input array
+ * @param varargs - Spacing between values (scalar or array per dimension)
+ * @param axis - Axis or axes along which to compute gradient
+ * @returns Array of gradients (one per axis) or single gradient
+ */
+export declare function gradient(f: NDArray, varargs?: number | number[], axis?: number | number[] | null): NDArray | NDArray[];
+/**
+ * Return the cross product of two (arrays of) vectors
+ * @param a - First input array
+ * @param b - Second input array
+ * @param axisa - Axis of a that defines the vector(s) (default: -1)
+ * @param axisb - Axis of b that defines the vector(s) (default: -1)
+ * @param axisc - Axis of c containing the cross product (default: -1)
+ * @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