numpy-ts 0.12.0 → 0.13.1

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

@@ -0,0 +1,880 @@
+import { type DType } from '../common/dtype';
+import { Complex } from '../common/complex';
+import { ArrayStorage } from '../common/storage';
+import { NDArrayCore } from '../common/ndarray-core';
+export declare class NDArray extends NDArrayCore {
+    /**
+     * Override _base with NDArray type
+     */
+    protected _base?: NDArray;
+    constructor(storage: ArrayStorage, base?: NDArray);
+    /**
+     * Create NDArray from storage (for ops modules)
+     * @internal
+     */
+    static fromStorage(storage: ArrayStorage, base?: NDArray): NDArray;
+    /**
+     * Base array if this is a view, null if this array owns its data
+     * Similar to NumPy's base attribute
+     */
+    get base(): NDArray | null;
+    /**
+     * Transpose of the array (shorthand for transpose())
+     * Returns a view with axes reversed
+     */
+    get T(): NDArray;
+    /**
+     * Size of one array element in bytes
+     */
+    get itemsize(): number;
+    /**
+     * Total bytes consumed by the elements of the array
+     */
+    get nbytes(): number;
+    /**
+     * Fill the array with a scalar value (in-place)
+     * @param value - Value to fill with
+     */
+    fill(value: number | bigint): void;
+    /**
+     * Iterator protocol - iterate over the first axis
+     * For 1D arrays, yields elements; for ND arrays, yields (N-1)D subarrays
+     */
+    [Symbol.iterator](): Iterator<NDArray | number | bigint | Complex>;
+    /**
+     * Get a single element from the array
+     * @param indices - Array of indices, one per dimension
+     * @returns The element value
+     */
+    get(indices: number[]): number | bigint | Complex;
+    /**
+     * Set a single element in the array
+     * @param indices - Array of indices, one per dimension
+     * @param value - Value to set
+     */
+    set(indices: number[], value: number | bigint | Complex | {
+        re: number;
+        im: number;
+    }): void;
+    /**
+     * Return a deep copy of the array
+     */
+    copy(): NDArray;
+    /**
+     * Cast array to a different dtype
+     * @param dtype - Target dtype
+     * @param copy - If false and dtype matches, return self
+     * @returns Array with specified dtype
+     */
+    astype(dtype: DType, copy?: boolean): NDArray;
+    /**
+     * Slice the array using NumPy-style string syntax
+     * @param sliceStrs - Slice specifications, one per dimension
+     * @returns Sliced view of the array
+     */
+    slice(...sliceStrs: string[]): NDArray;
+    /**
+     * Get a single row (convenience method)
+     * @param i - Row index
+     * @returns Row as 1D or (n-1)D array
+     */
+    row(i: number): NDArray;
+    /**
+     * Get a single column (convenience method)
+     * @param j - Column index
+     * @returns Column as 1D or (n-1)D array
+     */
+    col(j: number): NDArray;
+    /**
+     * Get a range of rows (convenience method)
+     * @param start - Start row index
+     * @param stop - Stop row index (exclusive)
+     * @returns Rows as array
+     */
+    rows(start: number, stop: number): NDArray;
+    /**
+     * Get a range of columns (convenience method)
+     * @param start - Start column index
+     * @param stop - Stop column index (exclusive)
+     * @returns Columns as array
+     */
+    cols(start: number, stop: number): NDArray;
+    /**
+     * Reshape array to a new shape
+     * Returns a new array with the specified shape
+     * @param shape - New shape (must be compatible with current size)
+     * @returns Reshaped array
+     */
+    reshape(...shape: number[]): NDArray;
+    /**
+     * Return a flattened array (view when possible, otherwise copy)
+     * @returns 1D array containing all elements
+     */
+    ravel(): NDArray;
+    /**
+     * Put values at specified indices (modifies array in-place)
+     * @param indices - Indices at which to place values
+     * @param values - Values to put
+     */
+    put(indices: number[], values: NDArray | number | bigint): void;
+    /**
+     * Return selected slices of this array along given axis
+     * @param condition - Boolean array that selects which entries to return
+     * @param axis - Axis along which to take slices
+     * @returns Array with selected entries
+     */
+    compress(condition: NDArray | boolean[], axis?: number): NDArray;
+    /**
+     * Construct an array from an index array and a list of arrays to choose from
+     * @param choices - Array of NDArrays to choose from
+     * @returns New array with selected elements
+     */
+    choose(choices: NDArray[]): NDArray;
+    /**
+     * Clip (limit) the values in an array
+     * @param a_min - Minimum value (null for no minimum)
+     * @param a_max - Maximum value (null for no maximum)
+     * @returns Array with values clipped to [a_min, a_max]
+     */
+    clip(a_min: number | NDArray | null, a_max: number | NDArray | null): NDArray;
+    /**
+     * Integer array indexing (fancy indexing)
+     *
+     * Select elements using an array of indices.
+     * @param indices - Array of integer indices
+     * @param axis - Axis along which to index (default: 0)
+     * @returns New array with selected elements
+     */
+    iindex(indices: NDArray | number[] | number[][], axis?: number): NDArray;
+    /**
+     * Boolean array indexing (fancy indexing with mask)
+     *
+     * Select elements where a boolean mask is true.
+     * @param mask - Boolean NDArray mask
+     * @param axis - Axis along which to apply the mask
+     * @returns New 1D array with selected elements
+     */
+    bindex(mask: NDArray, axis?: number): NDArray;
+    /**
+     * String representation of the array
+     * @returns String describing the array shape and dtype
+     */
+    toString(): string;
+    /**
+     * Convert to nested JavaScript array
+     * @returns Nested JavaScript array representation
+     */
+    toArray(): any;
+    /**
+     * Return the array as a nested list (same as toArray)
+     */
+    tolist(): any;
+    /**
+     * Return the raw bytes of the array data
+     */
+    tobytes(): ArrayBuffer;
+    /**
+     * Copy an element of an array to a standard scalar and return it
+     */
+    item(...args: number[]): number | bigint | Complex;
+    /**
+     * Swap the bytes of the array elements
+     */
+    byteswap(inplace?: boolean): NDArray;
+    /**
+     * Return a view of the array with a different dtype
+     */
+    view(dtype?: DType): NDArray;
+    /**
+     * Write array to a file (stub)
+     */
+    tofile(_file: string, _sep?: string, _format?: string): void;
+    /**
+     * 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 complex conjugate, element-wise (alias for conj)
+     * @returns Complex conjugate of the array
+     */
+    conjugate(): 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;
+    /**
+     * Element-wise comparison with tolerance
+     * Returns True where |a - b| <= (atol + rtol * |b|)
+     * @param other - Value or array to compare with
+     * @param rtol - Relative tolerance (default: 1e-5)
+     * @param atol - Absolute tolerance (default: 1e-8)
+     * @returns boolean
+     */
+    allclose(other: NDArray | number, rtol?: number, atol?: number): boolean;
+    /**
+     * Element-wise comparison with tolerance
+     * Returns True where |a - b| <= (atol + rtol * |b|)
+     * @param other - Value or array to compare with
+     * @param rtol - Relative tolerance (default: 1e-5)
+     * @param atol - Absolute tolerance (default: 1e-8)
+     * @returns Boolean array
+     */
+    isclose(other: NDArray | number, rtol?: number, atol?: number): NDArray;
+    /**
+     * Compute the weighted average along the specified axis
+     * @param weights - Array of weights (optional)
+     * @param axis - Axis along which to compute average
+     * @returns Weighted average of array elements
+     */
+    average(weights?: NDArray, axis?: number): NDArray | number | Complex;
+    /**
+     * Dot product (matching NumPy behavior)
+     * @param other - Array to dot with
+     * @returns Result of dot product
+     */
+    dot(other: NDArray): NDArray | number | bigint | Complex;
+    /**
+     * Sum of diagonal elements (trace)
+     * @returns Sum of diagonal elements
+     */
+    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
+     */
+    inner(other: NDArray): NDArray | number | bigint | Complex;
+    /**
+     * Tensor dot product along specified axes
+     * @param other - Array to contract with
+     * @param axes - Axes to contract
+     * @returns Tensor dot product result
+     */
+    tensordot(other: NDArray, axes?: number | [number[], number[]]): NDArray | number | bigint | Complex;
+    /**
+     * Returns both quotient and remainder (floor divide and modulo)
+     * @param divisor - Array or scalar divisor
+     * @returns Tuple of [quotient, remainder] arrays
+     */
+    divmod(divisor: NDArray | number): [NDArray, NDArray];
+    /**
+     * Find indices where elements should be inserted to maintain order
+     * @param v - Values to insert
+     * @param side - "left" or "right" side to insert
+     * @returns Indices where values should be inserted
+     */
+    searchsorted(v: NDArray, side?: 'left' | 'right'): NDArray;
+    /**
+     * Square root of each element
+     * Promotes integer types to float64
+     */
+    sqrt(): NDArray;
+    /**
+     * Natural exponential (e^x) of each element
+     * Promotes integer types to float64
+     */
+    exp(): NDArray;
+    /**
+     * Base-2 exponential (2^x) of each element
+     * Promotes integer types to float64
+     */
+    exp2(): NDArray;
+    /**
+     * Exponential minus one (e^x - 1) of each element
+     * More accurate than exp(x) - 1 for small x
+     */
+    expm1(): NDArray;
+    /**
+     * Natural logarithm (ln) of each element
+     * Promotes integer types to float64
+     */
+    log(): NDArray;
+    /**
+     * Base-2 logarithm of each element
+     * Promotes integer types to float64
+     */
+    log2(): NDArray;
+    /**
+     * Base-10 logarithm of each element
+     * Promotes integer types to float64
+     */
+    log10(): NDArray;
+    /**
+     * Natural logarithm of (1 + x) of each element
+     * More accurate than log(1 + x) for small x
+     */
+    log1p(): NDArray;
+    /**
+     * Absolute value of each element
+     */
+    absolute(): NDArray;
+    /**
+     * Numerical negative (element-wise negation)
+     */
+    negative(): NDArray;
+    /**
+     * Sign of each element (-1, 0, or 1)
+     */
+    sign(): NDArray;
+    /**
+     * Numerical positive (element-wise +x)
+     * @returns Copy of the array
+     */
+    positive(): NDArray;
+    /**
+     * Element-wise reciprocal (1/x)
+     */
+    reciprocal(): NDArray;
+    /**
+     * Return the ceiling of the input, element-wise
+     */
+    ceil(): NDArray;
+    /**
+     * Round to nearest integer towards zero
+     */
+    fix(): NDArray;
+    /**
+     * Return the floor of the input, element-wise
+     */
+    floor(): NDArray;
+    /**
+     * Round elements to the nearest integer
+     */
+    rint(): NDArray;
+    /**
+     * Return the truncated value of the input, element-wise
+     */
+    trunc(): NDArray;
+    /**
+     * Sine of each element (in radians)
+     * Promotes integer types to float64
+     */
+    sin(): NDArray;
+    /**
+     * Cosine of each element (in radians)
+     * Promotes integer types to float64
+     */
+    cos(): NDArray;
+    /**
+     * Tangent of each element (in radians)
+     * Promotes integer types to float64
+     */
+    tan(): NDArray;
+    /**
+     * Inverse sine of each element
+     * Promotes integer types to float64
+     */
+    arcsin(): NDArray;
+    /**
+     * Inverse cosine of each element
+     * Promotes integer types to float64
+     */
+    arccos(): NDArray;
+    /**
+     * Inverse tangent of each element
+     * Promotes integer types to float64
+     */
+    arctan(): NDArray;
+    /**
+     * Convert angles from radians to degrees
+     */
+    degrees(): NDArray;
+    /**
+     * Convert angles from degrees to radians
+     */
+    radians(): NDArray;
+    /**
+     * Hyperbolic sine of each element
+     * Promotes integer types to float64
+     */
+    sinh(): NDArray;
+    /**
+     * Hyperbolic cosine of each element
+     * Promotes integer types to float64
+     */
+    cosh(): NDArray;
+    /**
+     * Hyperbolic tangent of each element
+     * Promotes integer types to float64
+     */
+    tanh(): NDArray;
+    /**
+     * Inverse hyperbolic sine of each element
+     * Promotes integer types to float64
+     */
+    arcsinh(): NDArray;
+    /**
+     * Inverse hyperbolic cosine of each element
+     * Promotes integer types to float64
+     */
+    arccosh(): NDArray;
+    /**
+     * Inverse hyperbolic tangent of each element
+     * Promotes integer types to float64
+     */
+    arctanh(): NDArray;
+    /**
+     * Bitwise NOT (inversion) element-wise
+     */
+    bitwise_not(): NDArray;
+    /**
+     * Invert (bitwise NOT) element-wise - alias for bitwise_not
+     */
+    invert(): NDArray;
+    /**
+     * Logical NOT element-wise
+     * @returns Boolean array (1 = true, 0 = false)
+     */
+    logical_not(): NDArray;
+    /**
+     * Test element-wise for finiteness (not infinity and not NaN)
+     */
+    isfinite(): NDArray;
+    /**
+     * Test element-wise for positive or negative infinity
+     */
+    isinf(): NDArray;
+    /**
+     * Test element-wise for NaN (Not a Number)
+     */
+    isnan(): NDArray;
+    /**
+     * Test element-wise for NaT (Not a Time)
+     * @returns Boolean array (always false without datetime support)
+     */
+    isnat(): NDArray;
+    /**
+     * Returns element-wise True where signbit is set (less than zero)
+     */
+    signbit(): NDArray;
+    /**
+     * Return the distance between x and the nearest adjacent number
+     */
+    spacing(): NDArray;
+    /**
+     * Element-wise cube root
+     * Promotes integer types to float64
+     */
+    cbrt(): NDArray;
+    /**
+     * Element-wise absolute value (always returns float)
+     */
+    fabs(): NDArray;
+    /**
+     * Element-wise square (x**2)
+     */
+    square(): NDArray;
+    /**
+     * Return the complex conjugate, element-wise
+     */
+    conj(): NDArray;
+    /**
+     * Return a flattened copy of the array
+     * @returns 1D array containing all elements
+     */
+    flatten(): NDArray;
+    /**
+     * Find the indices of array elements that are non-zero, grouped by element
+     * @returns 2D array of shape (N, ndim)
+     */
+    argwhere(): NDArray;
+    /**
+     * Element-wise addition
+     * @param other - Array or scalar to add
+     */
+    add(other: NDArray | number): NDArray;
+    /**
+     * Element-wise subtraction
+     * @param other - Array or scalar to subtract
+     */
+    subtract(other: NDArray | number): NDArray;
+    /**
+     * Element-wise multiplication
+     * @param other - Array or scalar to multiply
+     */
+    multiply(other: NDArray | number): NDArray;
+    /**
+     * Element-wise division
+     * @param other - Array or scalar to divide by
+     */
+    divide(other: NDArray | number): NDArray;
+    /**
+     * Element-wise modulo operation
+     * @param other - Array or scalar divisor
+     */
+    mod(other: NDArray | number): NDArray;
+    /**
+     * Element-wise floor division
+     * @param other - Array or scalar to divide by
+     */
+    floor_divide(other: NDArray | number): NDArray;
+    /**
+     * Raise elements to power
+     * @param exponent - Power to raise to (array or scalar)
+     */
+    power(exponent: NDArray | number): NDArray;
+    /**
+     * Logarithm of the sum of exponentials: log(exp(x1) + exp(x2))
+     * @param x2 - Second operand
+     */
+    logaddexp(x2: NDArray | number): NDArray;
+    /**
+     * Logarithm base 2 of the sum of exponentials: log2(2^x1 + 2^x2)
+     * @param x2 - Second operand
+     */
+    logaddexp2(x2: NDArray | number): NDArray;
+    /**
+     * Element-wise arc tangent of this/other choosing the quadrant correctly
+     * @param other - x-coordinates
+     */
+    arctan2(other: NDArray | number): NDArray;
+    /**
+     * Given the "legs" of a right triangle, return its hypotenuse
+     * @param other - Second leg
+     */
+    hypot(other: NDArray | number): NDArray;
+    /**
+     * Element-wise greater than comparison
+     * @returns Boolean array
+     */
+    greater(other: NDArray | number): NDArray;
+    /**
+     * Element-wise greater than or equal comparison
+     * @returns Boolean array
+     */
+    greater_equal(other: NDArray | number): NDArray;
+    /**
+     * Element-wise less than comparison
+     * @returns Boolean array
+     */
+    less(other: NDArray | number): NDArray;
+    /**
+     * Element-wise less than or equal comparison
+     * @returns Boolean array
+     */
+    less_equal(other: NDArray | number): NDArray;
+    /**
+     * Element-wise equality comparison
+     * @returns Boolean array
+     */
+    equal(other: NDArray | number): NDArray;
+    /**
+     * Element-wise not equal comparison
+     * @returns Boolean array
+     */
+    not_equal(other: NDArray | number): NDArray;
+    /**
+     * Bitwise AND element-wise
+     * @param other - Array or scalar (must be integer type)
+     */
+    bitwise_and(other: NDArray | number): NDArray;
+    /**
+     * Bitwise OR element-wise
+     * @param other - Array or scalar (must be integer type)
+     */
+    bitwise_or(other: NDArray | number): NDArray;
+    /**
+     * Bitwise XOR element-wise
+     * @param other - Array or scalar (must be integer type)
+     */
+    bitwise_xor(other: NDArray | number): NDArray;
+    /**
+     * Left shift elements by positions
+     * @param shift - Shift amount
+     */
+    left_shift(shift: NDArray | number): NDArray;
+    /**
+     * Right shift elements by positions
+     * @param shift - Shift amount
+     */
+    right_shift(shift: NDArray | number): NDArray;
+    /**
+     * Logical AND element-wise
+     * @returns Boolean array (1 = true, 0 = false)
+     */
+    logical_and(other: NDArray | number): NDArray;
+    /**
+     * Logical OR element-wise
+     * @returns Boolean array (1 = true, 0 = false)
+     */
+    logical_or(other: NDArray | number): NDArray;
+    /**
+     * Logical XOR element-wise
+     * @returns Boolean array (1 = true, 0 = false)
+     */
+    logical_xor(other: NDArray | number): NDArray;
+    /**
+     * Change the sign of x1 to that of x2, element-wise
+     * @param x2 - Values whose sign is used
+     */
+    copysign(x2: NDArray | number): NDArray;
+    /**
+     * Return the next floating-point value after x1 towards x2, element-wise
+     * @param x2 - Direction to look
+     */
+    nextafter(x2: NDArray | number): NDArray;
+    /**
+     * Element-wise remainder (same as mod)
+     * @param divisor - Array or scalar divisor
+     */
+    remainder(divisor: NDArray | number): NDArray;
+    /**
+     * Heaviside step function
+     * @param x2 - Value to use when this array element is 0
+     */
+    heaviside(x2: NDArray | number): NDArray;
+    /**
+     * Matrix multiplication
+     * @param other - Array to multiply with
+     */
+    matmul(other: NDArray): NDArray;
+    /**
+     * Outer product (flattens inputs then computes a[i]*b[j])
+     * @param other - Array to compute outer product with
+     */
+    outer(other: NDArray): NDArray;
+    /**
+     * Sum array elements over a given axis
+     */
+    sum(axis?: number, keepdims?: boolean): NDArray | number | bigint | Complex;
+    /**
+     * Compute the arithmetic mean along the specified axis
+     */
+    mean(axis?: number, keepdims?: boolean): NDArray | number | Complex;
+    /**
+     * Product of array elements over a given axis
+     */
+    prod(axis?: number, keepdims?: boolean): NDArray | number | bigint | Complex;
+    /**
+     * Return the maximum along a given axis
+     */
+    max(axis?: number, keepdims?: boolean): NDArray | number | Complex;
+    /**
+     * Return the minimum along a given axis
+     */
+    min(axis?: number, keepdims?: boolean): NDArray | number | Complex;
+    /**
+     * Peak to peak (maximum - minimum) value along a given axis
+     */
+    ptp(axis?: number, keepdims?: boolean): NDArray | number | Complex;
+    /**
+     * Return the sum of array elements, treating NaNs as zero
+     */
+    nansum(axis?: number, keepdims?: boolean): NDArray | number | Complex;
+    /**
+     * Return the product of array elements, treating NaNs as ones
+     */
+    nanprod(axis?: number, keepdims?: boolean): NDArray | number | Complex;
+    /**
+     * Compute the arithmetic mean, ignoring NaNs
+     */
+    nanmean(axis?: number, keepdims?: boolean): NDArray | number | Complex;
+    /**
+     * Return minimum of an array, ignoring NaNs
+     */
+    nanmin(axis?: number, keepdims?: boolean): NDArray | number | Complex;
+    /**
+     * Return maximum of an array, ignoring NaNs
+     */
+    nanmax(axis?: number, keepdims?: boolean): NDArray | number | Complex;
+    /**
+     * Indices of the minimum values along an axis
+     */
+    argmin(axis?: number): NDArray | number;
+    /**
+     * Indices of the maximum values along an axis
+     */
+    argmax(axis?: number): NDArray | number;
+    /**
+     * Return the indices of the minimum values, ignoring NaNs
+     */
+    nanargmin(axis?: number): NDArray | number;
+    /**
+     * Return the indices of the maximum values, ignoring NaNs
+     */
+    nanargmax(axis?: number): NDArray | number;
+    /**
+     * Compute variance along the specified axis
+     * @param axis - Axis along which to compute variance
+     * @param ddof - Delta degrees of freedom (default: 0)
+     * @param keepdims - If true, reduced axes are left as dimensions with size 1
+     */
+    var(axis?: number, ddof?: number, keepdims?: boolean): NDArray | number;
+    /**
+     * Compute standard deviation along the specified axis
+     * @param axis - Axis along which to compute std
+     * @param ddof - Delta degrees of freedom (default: 0)
+     * @param keepdims - If true, reduced axes are left as dimensions with size 1
+     */
+    std(axis?: number, ddof?: number, keepdims?: boolean): NDArray | number;
+    /**
+     * Compute the variance, ignoring NaNs
+     * @param axis - Axis along which to compute variance
+     * @param ddof - Delta degrees of freedom (default: 0)
+     * @param keepdims - If true, reduced axes are left as dimensions with size 1
+     */
+    nanvar(axis?: number, ddof?: number, keepdims?: boolean): NDArray | number;
+    /**
+     * Compute the standard deviation, ignoring NaNs
+     * @param axis - Axis along which to compute std
+     * @param ddof - Delta degrees of freedom (default: 0)
+     * @param keepdims - If true, reduced axes are left as dimensions with size 1
+     */
+    nanstd(axis?: number, ddof?: number, keepdims?: boolean): NDArray | number;
+    /**
+     * Test whether all array elements along a given axis evaluate to True
+     */
+    all(axis?: number, keepdims?: boolean): NDArray | boolean;
+    /**
+     * Test whether any array elements along a given axis evaluate to True
+     */
+    any(axis?: number, keepdims?: boolean): NDArray | boolean;
+    /**
+     * Compute the median along the specified axis
+     */
+    median(axis?: number, keepdims?: boolean): NDArray | number;
+    /**
+     * Compute the median, ignoring NaNs
+     */
+    nanmedian(axis?: number, keepdims?: boolean): NDArray | number;
+    /**
+     * Compute the q-th percentile of the data along the specified axis
+     * @param q - Percentile to compute (0-100)
+     */
+    percentile(q: number, axis?: number, keepdims?: boolean): NDArray | number;
+    /**
+     * Compute the q-th quantile of the data along the specified axis
+     * @param q - Quantile to compute (0-1)
+     */
+    quantile(q: number, axis?: number, keepdims?: boolean): NDArray | number;
+    /**
+     * Compute the q-th quantile, ignoring NaNs
+     * @param q - Quantile to compute (0-1)
+     */
+    nanquantile(q: number, axis?: number, keepdims?: boolean): NDArray | number;
+    /**
+     * Compute the q-th percentile, ignoring NaNs
+     * @param q - Percentile to compute (0-100)
+     */
+    nanpercentile(q: number, axis?: number, keepdims?: boolean): NDArray | number;
+    /**
+     * Return the cumulative sum of elements along a given axis
+     */
+    cumsum(axis?: number): NDArray;
+    /**
+     * Return the cumulative product of elements along a given axis
+     */
+    cumprod(axis?: number): NDArray;
+    /**
+     * Return the cumulative sum of elements, treating NaNs as zero
+     */
+    nancumsum(axis?: number): NDArray;
+    /**
+     * Return the cumulative product of elements, treating NaNs as one
+     */
+    nancumprod(axis?: number): NDArray;
+    /**
+     * Return a sorted copy of the array
+     * @param axis - Axis along which to sort. Default is -1 (last axis)
+     */
+    sort(axis?: number): NDArray;
+    /**
+     * Returns the indices that would sort this array
+     * @param axis - Axis along which to sort. Default is -1 (last axis)
+     */
+    argsort(axis?: number): NDArray;
+    /**
+     * Partially sort the array
+     * @param kth - Element index to partition by
+     * @param axis - Axis along which to sort. Default is -1 (last axis)
+     */
+    partition(kth: number, axis?: number): NDArray;
+    /**
+     * Returns indices that would partition the array
+     * @param kth - Element index to partition by
+     * @param axis - Axis along which to sort. Default is -1 (last axis)
+     */
+    argpartition(kth: number, axis?: number): NDArray;
+    /**
+     * Return specified diagonals
+     * @param offset - Offset of the diagonal from the main diagonal
+     * @param axis1 - First axis of the 2-D sub-arrays
+     * @param axis2 - Second axis of the 2-D sub-arrays
+     */
+    diagonal(offset?: number, axis1?: number, axis2?: number): NDArray;
+    /**
+     * Return a new array with the specified shape
+     * If larger, filled with repeated copies of the original data
+     * @param newShape - Shape of the resized array
+     */
+    resize(newShape: number[]): 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)
+     */
+    diff(n?: number, axis?: number): NDArray;
+    /**
+     * Take elements from array along an axis
+     * @param indices - Indices of elements to take
+     * @param axis - Axis along which to take
+     */
+    take(indices: number[], axis?: number): NDArray;
+    /**
+     * Repeat elements of an array
+     * @param repeats - Number of repetitions for each element
+     * @param axis - Axis along which to repeat
+     */
+    repeat(repeats: number | number[], axis?: number): NDArray;
+    /**
+     * Transpose array (permute dimensions)
+     * @param axes - Permutation of axes. If undefined, reverse the dimensions
+     * @returns Transposed array (always a view)
+     */
+    transpose(axes?: number[]): NDArray;
+    /**
+     * Remove axes of length 1
+     * @param axis - Axis to squeeze
+     * @returns Array with specified dimensions removed (always a view)
+     */
+    squeeze(axis?: number): NDArray;
+    /**
+     * Expand the shape by inserting a new axis of length 1
+     * @param axis - Position where new axis is placed
+     * @returns Array with additional dimension (always a view)
+     */
+    expand_dims(axis: number): NDArray;
+    /**
+     * Swap two axes of an array
+     * @param axis1 - First axis
+     * @param axis2 - Second axis
+     * @returns Array with swapped axes (always a view)
+     */
+    swapaxes(axis1: number, axis2: number): NDArray;
+    /**
+     * Move axes to new positions
+     * @param source - Original positions of axes to move
+     * @param destination - New positions for axes
+     * @returns Array with moved axes (always a view)
+     */
+    moveaxis(source: number | number[], destination: number | number[]): NDArray;
+    /**
+     * Return the indices of non-zero elements
+     * @returns Tuple of arrays, one for each dimension
+     */
+    nonzero(): NDArray[];
+}
+/**
+ * Return coordinate matrices from coordinate vectors
+ * @param arrays - 1D coordinate arrays
+ * @param indexing - 'xy' (Cartesian, default) or 'ij' (matrix indexing)
+ * @returns Array of coordinate grids
+ */
+export declare function meshgrid(...args: (NDArray | {
+    indexing?: 'xy' | 'ij';
+})[]): NDArray[];
+//# sourceMappingURL=ndarray.d.ts.map