numpy-ts 0.9.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)
@@ -421,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
@@ -662,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
@@ -1131,6 +1225,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 +1292,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 +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
@@ -1341,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
@@ -1360,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
@@ -1416,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
  *
@@ -1746,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
  *
@@ -1779,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
@@ -1786,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
@@ -1968,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
  *
@@ -2046,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
  *
@@ -2222,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.
  *
@@ -2364,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
@@ -2408,6 +2802,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 +2932,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

package/dist/types/index.d.ts

@@ -3,7 +3,46 @@
  *
  * @module numpy-ts
  */
-export { NDArray, zeros, ones, array, arange, linspace, logspace, geomspace, eye, empty, full, identity, asarray, copy, zeros_like, ones_like, empty_like, full_like, asanyarray, ascontiguousarray, asfortranarray, diag, diagflat, frombuffer, fromfile, fromfunction, fromiter, fromstring, meshgrid, tri, tril, triu, vander, sqrt, power, exp, exp2, expm1, log, log2, log10, log1p, logaddexp, logaddexp2, absolute, negative, sign, mod, floor_divide, positive, reciprocal, cbrt, fabs, divmod, square, remainder, heaviside, dot, trace, diagonal, kron, transpose, inner, outer, tensordot, einsum, linalg, sin, cos, tan, arcsin, arccos, arctan, arctan2, hypot, degrees, radians, deg2rad, rad2deg, sinh, cosh, tanh, arcsinh, arccosh, arctanh, swapaxes, moveaxis, concatenate, stack, vstack, hstack, dstack, split, array_split, vsplit, hsplit, tile, repeat, ravel, reshape, squeeze, expand_dims, flip, fliplr, flipud, rot90, roll, rollaxis, atleast_1d, atleast_2d, atleast_3d, dsplit, column_stack, row_stack, resize, append, delete_ as delete, insert, pad, broadcast_to, broadcast_arrays, broadcast_shapes, take, put, choose, array_equal, array_equiv, take_along_axis, put_along_axis, putmask, compress, select, place, diag_indices, diag_indices_from, tril_indices, tril_indices_from, triu_indices, triu_indices_from, mask_indices, indices, ix_, ravel_multi_index, unravel_index, cumsum, cumprod, ptp, median, percentile, quantile, average, nansum, nanprod, nanmean, nanvar, nanstd, nanmin, nanmax, nanargmin, nanargmax, nancumsum, nancumprod, nanmedian, bitwise_and, bitwise_or, bitwise_xor, bitwise_not, invert, left_shift, right_shift, packbits, unpackbits, sort, argsort, lexsort, partition, argpartition, sort_complex, nonzero, flatnonzero, where, searchsorted, extract, count_nonzero, around, ceil, fix, floor, rint, round, trunc, unique, in1d, intersect1d, isin, setdiff1d, setxor1d, union1d, diff, ediff1d, gradient, cross, } from './core/ndarray';
+export { NDArray, zeros, ones, array, arange, linspace, logspace, geomspace, eye, empty, full, identity, asarray, copy, zeros_like, ones_like, empty_like, full_like, asanyarray, ascontiguousarray, asfortranarray, diag, diagflat, frombuffer, fromfile, fromfunction, fromiter, fromstring, meshgrid, tri, tril, triu, vander, sqrt, power, pow, // alias for power
+exp, exp2, expm1, log, log2, log10, log1p, logaddexp, logaddexp2, absolute, abs, // alias for absolute
+negative, sign, mod, divide, true_divide, // alias for divide
+floor_divide, positive, reciprocal, cbrt, fabs, divmod, square, remainder, heaviside, float_power, fmod, frexp, gcd, lcm, ldexp, modf, dot, trace, diagonal, kron, transpose, inner, outer, tensordot, einsum, linalg, sin, cos, tan, arcsin, asin, // alias for arcsin
+arccos, acos, // alias for arccos
+arctan, atan, // alias for arctan
+arctan2, atan2, // alias for arctan2
+hypot, degrees, radians, deg2rad, rad2deg, sinh, cosh, tanh, arcsinh, asinh, // alias for arcsinh
+arccosh, acosh, // alias for arccosh
+arctanh, atanh, // alias for arctanh
+swapaxes, moveaxis, concatenate, stack, vstack, hstack, dstack, split, array_split, vsplit, hsplit, tile, repeat, ravel, reshape, squeeze, expand_dims, flip, fliplr, flipud, rot90, roll, rollaxis, atleast_1d, atleast_2d, atleast_3d, dsplit, column_stack, row_stack, resize, append, delete_ as delete, insert, pad, broadcast_to, broadcast_arrays, broadcast_shapes, take, put, copyto, choose, array_equal, array_equiv, take_along_axis, put_along_axis, putmask, compress, select, place, fill_diagonal, diag_indices, diag_indices_from, tril_indices, tril_indices_from, triu_indices, triu_indices_from, mask_indices, indices, ix_, ravel_multi_index, unravel_index, cumsum, cumulative_sum, // alias for cumsum
+cumprod, cumulative_prod, // alias for cumprod
+max, amax, // alias for max
+min, amin, // alias for min
+ptp, median, percentile, quantile, average, nansum, nanprod, nanmean, nanvar, nanstd, nanmin, nanmax, nanargmin, nanargmax, nancumsum, nancumprod, nanmedian, bitwise_and, bitwise_or, bitwise_xor, bitwise_not, invert, left_shift, right_shift, packbits, unpackbits, logical_and, logical_or, logical_not, logical_xor, isfinite, isinf, isnan, isnat, iscomplex, iscomplexobj, isreal, isrealobj, isneginf, isposinf, isfortran, real_if_close, isscalar, iterable, isdtype, promote_types, copysign, signbit, nextafter, spacing, sort, argsort, lexsort, partition, argpartition, sort_complex, nonzero, argwhere, flatnonzero, where, searchsorted, extract, count_nonzero, around, round_, // alias for around
+ceil, fix, floor, rint, round, trunc, unique, in1d, intersect1d, isin, setdiff1d, setxor1d, union1d, diff, ediff1d, gradient, cross, bincount, digitize, histogram, histogram2d, histogramdd, correlate, convolve, cov, corrcoef, } from './core/ndarray';
 export { parseNpy, serializeNpy, parseNpyHeader, parseNpyData, UnsupportedDTypeError, InvalidNpyError, SUPPORTED_DTYPES, DTYPE_TO_DESCR, type NpyHeader, type NpyMetadata, type NpyVersion, parseNpz, parseNpzSync, loadNpz, loadNpzSync, serializeNpz, serializeNpzSync, type NpzParseOptions, type NpzParseResult, type NpzSerializeOptions, } from './io';
+import * as randomOps from './ops/random';
+import { ArrayStorage } from './core/storage';
+import { NDArray as NDArrayClass } from './core/ndarray';
+import { DType } from './core/dtype';
+export declare const random: {
+    seed: typeof randomOps.seed;
+    random: (size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    rand: (...shape: number[]) => number | ArrayStorage | NDArrayClass;
+    randn: (...shape: number[]) => number | ArrayStorage | NDArrayClass;
+    randint: (low: number, high?: number | null, size?: number | number[], dtype?: DType) => number | ArrayStorage | NDArrayClass;
+    uniform: (low?: number, high?: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    normal: (loc?: number, scale?: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    standard_normal: (size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    exponential: (scale?: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    poisson: (lam?: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    binomial: (n: number, p: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    choice: (a: number | ArrayStorage, size?: number | number[], replace?: boolean, p?: ArrayStorage | number[]) => number | ArrayStorage | NDArrayClass;
+    permutation: (x: number | ArrayStorage) => ArrayStorage | NDArrayClass;
+    shuffle: typeof randomOps.shuffle;
+    get_state: typeof randomOps.get_state;
+    set_state: typeof randomOps.set_state;
+    default_rng: typeof randomOps.default_rng;
+    Generator: typeof randomOps.Generator;
+};
 export declare const __version__: string;
 //# sourceMappingURL=index.d.ts.map

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

@@ -105,4 +105,11 @@ export declare function ravel_multi_index(multi_index: ArrayStorage[], dims: num
  * Convert flat index array to tuple of coordinate arrays
  */
 export declare function unravel_index(indices: ArrayStorage | number, shape: number[], order?: 'C' | 'F'): ArrayStorage[];
+/**
+ * Fill the main diagonal of a given array (modifies in-place)
+ * @param a - Array storage (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: ArrayStorage, val: ArrayStorage | number, wrap?: boolean): void;
 //# sourceMappingURL=advanced.d.ts.map