numpy-ts 0.12.0 → 0.13.0

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

@@ -1,3923 +0,0 @@
-/**
- * NDArray - NumPy-compatible multidimensional array
- *
- * Core array class providing NumPy-like API
- */
-import { type DType, type TypedArray } from './dtype';
-import { Complex } from './complex';
-import { ArrayStorage } from './storage';
-export declare class NDArray {
-    private _storage;
-    private _base?;
-    constructor(storage: ArrayStorage, base?: NDArray);
-    /**
-     * Get internal storage (for ops modules)
-     * @internal
-     */
-    get storage(): ArrayStorage;
-    /**
-     * Create NDArray from storage (for ops modules)
-     * @internal
-     */
-    static _fromStorage(storage: ArrayStorage, base?: NDArray): NDArray;
-    get shape(): readonly number[];
-    get ndim(): number;
-    get size(): number;
-    get dtype(): string;
-    get data(): TypedArray;
-    get strides(): readonly number[];
-    /**
-     * Array flags (similar to NumPy's flags)
-     * Provides information about memory layout
-     */
-    get flags(): {
-        C_CONTIGUOUS: boolean;
-        F_CONTIGUOUS: boolean;
-        OWNDATA: boolean;
-    };
-    /**
-     * 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 (e.g., [0, 1] for 2D array)
-     * @returns The element value (BigInt for int64/uint64, Complex for complex, number otherwise)
-     */
-    get(indices: number[]): number | bigint | Complex;
-    /**
-     * Set a single element in the array
-     * @param indices - Array of indices, one per dimension (e.g., [0, 1] for 2D array)
-     * @param value - Value to set (will be converted to array's dtype)
-     */
-    set(indices: number[], value: number | bigint | 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; otherwise create copy (default: true)
-     * @returns Array with specified dtype
-     */
-    astype(dtype: DType, copy?: boolean): NDArray;
-    /**
-     * Element-wise addition
-     * @param other - Array or scalar to add
-     * @returns Result of addition with broadcasting
-     */
-    add(other: NDArray | number): NDArray;
-    /**
-     * Element-wise subtraction
-     * @param other - Array or scalar to subtract
-     * @returns Result of subtraction with broadcasting
-     */
-    subtract(other: NDArray | number): NDArray;
-    /**
-     * Element-wise multiplication
-     * @param other - Array or scalar to multiply
-     * @returns Result of multiplication with broadcasting
-     */
-    multiply(other: NDArray | number): NDArray;
-    /**
-     * Element-wise division
-     * @param other - Array or scalar to divide by
-     * @returns Result of division with broadcasting
-     */
-    divide(other: NDArray | number): NDArray;
-    /**
-     * Element-wise modulo operation
-     * @param other - Array or scalar divisor
-     * @returns Remainder after division
-     */
-    mod(other: NDArray | number): NDArray;
-    /**
-     * Element-wise floor division
-     * @param other - Array or scalar to divide by
-     * @returns Floor of the quotient
-     */
-    floor_divide(other: NDArray | number): NDArray;
-    /**
-     * Numerical positive (element-wise +x)
-     * @returns Copy of the array
-     */
-    positive(): NDArray;
-    /**
-     * Element-wise reciprocal (1/x)
-     * @returns New array with reciprocals
-     */
-    reciprocal(): NDArray;
-    /**
-     * Square root of each element
-     * Promotes integer types to float64
-     * @returns New array with square roots
-     */
-    sqrt(): NDArray;
-    /**
-     * Raise elements to power
-     * @param exponent - Power to raise to (array or scalar)
-     * @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
-     */
-    absolute(): NDArray;
-    /**
-     * Numerical negative (element-wise negation)
-     * @returns New array with negated values
-     */
-    negative(): NDArray;
-    /**
-     * Sign of each element (-1, 0, or 1)
-     * @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
-     * @returns New array with sine values
-     */
-    sin(): NDArray;
-    /**
-     * Cosine of each element (in radians)
-     * Promotes integer types to float64
-     * @returns New array with cosine values
-     */
-    cos(): NDArray;
-    /**
-     * Tangent of each element (in radians)
-     * Promotes integer types to float64
-     * @returns New array with tangent values
-     */
-    tan(): NDArray;
-    /**
-     * Inverse sine of each element
-     * Promotes integer types to float64
-     * @returns New array with arcsin values (radians)
-     */
-    arcsin(): NDArray;
-    /**
-     * Inverse cosine of each element
-     * Promotes integer types to float64
-     * @returns New array with arccos values (radians)
-     */
-    arccos(): NDArray;
-    /**
-     * Inverse tangent of each element
-     * Promotes integer types to float64
-     * @returns New array with arctan values (radians)
-     */
-    arctan(): NDArray;
-    /**
-     * Element-wise arc tangent of this/other choosing the quadrant correctly
-     * @param other - x-coordinates (array or scalar)
-     * @returns Angle in radians between -π and π
-     */
-    arctan2(other: NDArray | number): NDArray;
-    /**
-     * Given the "legs" of a right triangle, return its hypotenuse
-     * Equivalent to sqrt(this**2 + other**2), element-wise
-     * @param other - Second leg (array or scalar)
-     * @returns Hypotenuse values
-     */
-    hypot(other: NDArray | number): NDArray;
-    /**
-     * Convert angles from radians to degrees
-     * @returns New array with angles in degrees
-     */
-    degrees(): NDArray;
-    /**
-     * Convert angles from degrees to radians
-     * @returns New array with angles in radians
-     */
-    radians(): NDArray;
-    /**
-     * Hyperbolic sine of each element
-     * Promotes integer types to float64
-     * @returns New array with sinh values
-     */
-    sinh(): NDArray;
-    /**
-     * Hyperbolic cosine of each element
-     * Promotes integer types to float64
-     * @returns New array with cosh values
-     */
-    cosh(): NDArray;
-    /**
-     * Hyperbolic tangent of each element
-     * Promotes integer types to float64
-     * @returns New array with tanh values
-     */
-    tanh(): NDArray;
-    /**
-     * Inverse hyperbolic sine of each element
-     * Promotes integer types to float64
-     * @returns New array with arcsinh values
-     */
-    arcsinh(): NDArray;
-    /**
-     * Inverse hyperbolic cosine of each element
-     * Promotes integer types to float64
-     * @returns New array with arccosh values
-     */
-    arccosh(): NDArray;
-    /**
-     * Inverse hyperbolic tangent of each element
-     * Promotes integer types to float64
-     * @returns New array with arctanh values
-     */
-    arctanh(): NDArray;
-    /**
-     * Element-wise greater than comparison
-     * @param other - Value or array to compare with
-     * @returns Boolean array (represented as uint8: 1=true, 0=false)
-     */
-    greater(other: NDArray | number): NDArray;
-    /**
-     * Element-wise greater than or equal comparison
-     * @param other - Value or array to compare with
-     * @returns Boolean array (represented as uint8: 1=true, 0=false)
-     */
-    greater_equal(other: NDArray | number): NDArray;
-    /**
-     * Element-wise less than comparison
-     * @param other - Value or array to compare with
-     * @returns Boolean array (represented as uint8: 1=true, 0=false)
-     */
-    less(other: NDArray | number): NDArray;
-    /**
-     * Element-wise less than or equal comparison
-     * @param other - Value or array to compare with
-     * @returns Boolean array (represented as uint8: 1=true, 0=false)
-     */
-    less_equal(other: NDArray | number): NDArray;
-    /**
-     * Element-wise equality comparison
-     * @param other - Value or array to compare with
-     * @returns Boolean array (represented as uint8: 1=true, 0=false)
-     */
-    equal(other: NDArray | number): NDArray;
-    /**
-     * Element-wise not equal comparison
-     * @param other - Value or array to compare with
-     * @returns Boolean array (represented as uint8: 1=true, 0=false)
-     */
-    not_equal(other: NDArray | 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 array (represented as uint8: 1=true, 0=false)
-     */
-    isclose(other: NDArray | number, rtol?: number, atol?: 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 array (represented as uint8: 1=true, 0=false)
-     */
-    allclose(other: NDArray | number, rtol?: number, atol?: number): boolean;
-    /**
-     * Bitwise AND element-wise
-     * @param other - Array or scalar for AND operation (must be integer type)
-     * @returns Result of bitwise AND
-     */
-    bitwise_and(other: NDArray | number): NDArray;
-    /**
-     * Bitwise OR element-wise
-     * @param other - Array or scalar for OR operation (must be integer type)
-     * @returns Result of bitwise OR
-     */
-    bitwise_or(other: NDArray | number): NDArray;
-    /**
-     * Bitwise XOR element-wise
-     * @param other - Array or scalar for XOR operation (must be integer type)
-     * @returns Result of bitwise XOR
-     */
-    bitwise_xor(other: NDArray | number): NDArray;
-    /**
-     * Bitwise NOT (inversion) element-wise
-     * @returns Result of bitwise NOT
-     */
-    bitwise_not(): NDArray;
-    /**
-     * Invert (bitwise NOT) element-wise - alias for bitwise_not
-     * @returns Result of bitwise inversion
-     */
-    invert(): NDArray;
-    /**
-     * Left shift elements by positions
-     * @param shift - Shift amount (array or scalar)
-     * @returns Result of left shift
-     */
-    left_shift(shift: NDArray | number): NDArray;
-    /**
-     * Right shift elements by positions
-     * @param shift - Shift amount (array or scalar)
-     * @returns Result of right shift
-     */
-    right_shift(shift: NDArray | number): NDArray;
-    /**
-     * Logical AND element-wise
-     * @param other - Array or scalar for AND operation
-     * @returns Boolean array (1 = true, 0 = false)
-     */
-    logical_and(other: NDArray | number): NDArray;
-    /**
-     * Logical OR element-wise
-     * @param other - Array or scalar for OR operation
-     * @returns Boolean array (1 = true, 0 = false)
-     */
-    logical_or(other: NDArray | number): NDArray;
-    /**
-     * Logical NOT element-wise
-     * @returns Boolean array (1 = true, 0 = false)
-     */
-    logical_not(): NDArray;
-    /**
-     * Logical XOR element-wise
-     * @param other - Array or scalar for XOR operation
-     * @returns Boolean array (1 = true, 0 = false)
-     */
-    logical_xor(other: NDArray | number): NDArray;
-    /**
-     * Test element-wise for finiteness (not infinity and not NaN)
-     * @returns Boolean array
-     */
-    isfinite(): NDArray;
-    /**
-     * Test element-wise for positive or negative infinity
-     * @returns Boolean array
-     */
-    isinf(): NDArray;
-    /**
-     * Test element-wise for NaN (Not a Number)
-     * @returns Boolean array
-     */
-    isnan(): NDArray;
-    /**
-     * Test element-wise for NaT (Not a Time)
-     * @returns Boolean array (always false without datetime support)
-     */
-    isnat(): NDArray;
-    /**
-     * Change the sign of x1 to that of x2, element-wise
-     * @param x2 - Values whose sign is used
-     * @returns Array with magnitude from this and sign from x2
-     */
-    copysign(x2: NDArray | number): NDArray;
-    /**
-     * Returns element-wise True where signbit is set (less than zero)
-     * @returns Boolean array
-     */
-    signbit(): NDArray;
-    /**
-     * Return the next floating-point value after x1 towards x2, element-wise
-     * @param x2 - Direction to look for the next representable value
-     * @returns Array of next representable values
-     */
-    nextafter(x2: NDArray | number): NDArray;
-    /**
-     * Return the distance between x and the nearest adjacent number
-     * @returns Array of spacing values
-     */
-    spacing(): NDArray;
-    /**
-     * Sum array elements over a given axis
-     * @param axis - Axis along which to sum. If undefined, sum all elements
-     * @param keepdims - If true, reduced axes are left as dimensions with size 1
-     * @returns Sum of array elements, or array of sums along axis
-     */
-    sum(axis?: number, keepdims?: boolean): NDArray | number | Complex;
-    /**
-     * Compute the arithmetic mean along the specified axis
-     * @param axis - Axis along which to compute mean. If undefined, compute mean of all elements
-     * @param keepdims - If true, reduced axes are left as dimensions with size 1
-     * @returns Mean of array elements, or array of means along axis
-     *
-     * Note: mean() returns float64 for integer dtypes, matching NumPy behavior
-     */
-    mean(axis?: number, keepdims?: boolean): NDArray | number | Complex;
-    /**
-     * Return the maximum along a given axis
-     * @param axis - Axis along which to compute maximum. If undefined, compute maximum of all elements
-     * @param keepdims - If true, reduced axes are left as dimensions with size 1
-     * @returns Maximum of array elements, or array of maximums along axis
-     */
-    max(axis?: number, keepdims?: boolean): NDArray | number | Complex;
-    /**
-     * Return the minimum along a given axis
-     * @param axis - Axis along which to compute minimum. If undefined, compute minimum of all elements
-     * @param keepdims - If true, reduced axes are left as dimensions with size 1
-     * @returns Minimum of array elements, or array of minimums along axis
-     */
-    min(axis?: number, keepdims?: boolean): NDArray | number | Complex;
-    /**
-     * Product of array elements over a given axis
-     * @param axis - Axis along which to compute the product. If undefined, product of all elements.
-     * @param keepdims - If true, reduced axes are left as dimensions with size 1
-     * @returns Product of array elements, or array of products along axis
-     */
-    prod(axis?: number, keepdims?: boolean): NDArray | number | Complex;
-    /**
-     * Indices of the minimum values along an axis
-     * @param axis - Axis along which to find minimum indices. If undefined, index of global minimum.
-     * @returns Indices of minimum values
-     */
-    argmin(axis?: number): NDArray | number;
-    /**
-     * Indices of the maximum values along an axis
-     * @param axis - Axis along which to find maximum indices. If undefined, index of global maximum.
-     * @returns Indices of maximum values
-     */
-    argmax(axis?: number): NDArray | number;
-    /**
-     * Compute variance along the specified axis
-     * @param axis - Axis along which to compute variance. If undefined, variance of all elements.
-     * @param ddof - Delta degrees of freedom (default: 0)
-     * @param keepdims - If true, reduced axes are left as dimensions with size 1
-     * @returns Variance of array elements
-     */
-    var(axis?: number, ddof?: number, keepdims?: boolean): NDArray | number;
-    /**
-     * Compute standard deviation along the specified axis
-     * @param axis - Axis along which to compute std. If undefined, std of all elements.
-     * @param ddof - Delta degrees of freedom (default: 0)
-     * @param keepdims - If true, reduced axes are left as dimensions with size 1
-     * @returns Standard deviation of array elements
-     */
-    std(axis?: number, ddof?: number, keepdims?: boolean): NDArray | number;
-    /**
-     * Test whether all array elements along a given axis evaluate to True
-     * @param axis - Axis along which to perform logical AND. If undefined, test all elements.
-     * @param keepdims - If true, reduced axes are left as dimensions with size 1
-     * @returns Boolean or array of booleans
-     */
-    all(axis?: number, keepdims?: boolean): NDArray | boolean;
-    /**
-     * Test whether any array elements along a given axis evaluate to True
-     * @param axis - Axis along which to perform logical OR. If undefined, test all elements.
-     * @param keepdims - If true, reduced axes are left as dimensions with size 1
-     * @returns Boolean or array of booleans
-     */
-    any(axis?: number, keepdims?: boolean): NDArray | boolean;
-    /**
-     * Return the cumulative sum of elements along a given axis
-     * @param axis - Axis along which to compute cumsum. If undefined, compute over flattened array.
-     * @returns Array with cumulative sums
-     */
-    cumsum(axis?: number): NDArray;
-    /**
-     * Return the cumulative product of elements along a given axis
-     * @param axis - Axis along which to compute cumprod. If undefined, compute over flattened array.
-     * @returns Array with cumulative products
-     */
-    cumprod(axis?: number): NDArray;
-    /**
-     * Peak to peak (maximum - minimum) value along a given axis
-     * @param axis - Axis along which to compute ptp. If undefined, compute over all elements.
-     * @param keepdims - If true, reduced axes are left as dimensions with size 1
-     * @returns Range of values
-     */
-    ptp(axis?: number, keepdims?: boolean): NDArray | number | Complex;
-    /**
-     * Compute the median along the specified axis
-     * @param axis - Axis along which to compute median. If undefined, compute over all elements.
-     * @param keepdims - If true, reduced axes are left as dimensions with size 1
-     * @returns Median of array elements
-     */
-    median(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)
-     * @param axis - Axis along which to compute percentile. If undefined, compute over all elements.
-     * @param keepdims - If true, reduced axes are left as dimensions with size 1
-     * @returns Percentile of array elements
-     */
-    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)
-     * @param axis - Axis along which to compute quantile. If undefined, compute over all elements.
-     * @param keepdims - If true, reduced axes are left as dimensions with size 1
-     * @returns Quantile of array elements
-     */
-    quantile(q: number, axis?: number, keepdims?: boolean): NDArray | number;
-    /**
-     * Compute the weighted average along the specified axis
-     * @param weights - Array of weights (optional)
-     * @param axis - Axis along which to compute average. If undefined, compute over all elements.
-     * @returns Weighted average of array elements
-     */
-    average(weights?: NDArray, axis?: number): NDArray | number | Complex;
-    /**
-     * Return the sum of array elements, treating NaNs as zero
-     * @param axis - Axis along which to compute sum. If undefined, compute over all elements.
-     * @param keepdims - If true, reduced axes are left as dimensions with size 1
-     * @returns Sum of array elements ignoring NaNs
-     */
-    nansum(axis?: number, keepdims?: boolean): NDArray | number | Complex;
-    /**
-     * Return the product of array elements, treating NaNs as ones
-     * @param axis - Axis along which to compute product. If undefined, compute over all elements.
-     * @param keepdims - If true, reduced axes are left as dimensions with size 1
-     * @returns Product of array elements ignoring NaNs
-     */
-    nanprod(axis?: number, keepdims?: boolean): NDArray | number | Complex;
-    /**
-     * Compute the arithmetic mean, ignoring NaNs
-     * @param axis - Axis along which to compute mean. If undefined, compute over all elements.
-     * @param keepdims - If true, reduced axes are left as dimensions with size 1
-     * @returns Mean of array elements ignoring NaNs
-     */
-    nanmean(axis?: number, keepdims?: boolean): NDArray | number | Complex;
-    /**
-     * Compute the variance, ignoring NaNs
-     * @param axis - Axis along which to compute variance. If undefined, compute over all elements.
-     * @param ddof - Delta degrees of freedom (default: 0)
-     * @param keepdims - If true, reduced axes are left as dimensions with size 1
-     * @returns Variance of array elements ignoring NaNs
-     */
-    nanvar(axis?: number, ddof?: number, keepdims?: boolean): NDArray | number;
-    /**
-     * Compute the standard deviation, ignoring NaNs
-     * @param axis - Axis along which to compute std. If undefined, compute over all elements.
-     * @param ddof - Delta degrees of freedom (default: 0)
-     * @param keepdims - If true, reduced axes are left as dimensions with size 1
-     * @returns Standard deviation of array elements ignoring NaNs
-     */
-    nanstd(axis?: number, ddof?: number, keepdims?: boolean): NDArray | number;
-    /**
-     * Return minimum of an array or minimum along an axis, ignoring NaNs
-     * @param axis - Axis along which to compute minimum. If undefined, compute over all elements.
-     * @param keepdims - If true, reduced axes are left as dimensions with size 1
-     * @returns Minimum of array elements ignoring NaNs
-     */
-    nanmin(axis?: number, keepdims?: boolean): NDArray | number | Complex;
-    /**
-     * Return maximum of an array or maximum along an axis, ignoring NaNs
-     * @param axis - Axis along which to compute maximum. If undefined, compute over all elements.
-     * @param keepdims - If true, reduced axes are left as dimensions with size 1
-     * @returns Maximum of array elements ignoring NaNs
-     */
-    nanmax(axis?: number, keepdims?: boolean): NDArray | number | Complex;
-    /**
-     * Compute the q-th quantile of the data along the specified axis, ignoring NaNs
-     * @param q - Quantile to compute (0-1)
-     * @param axis - Axis along which to compute quantile. If undefined, compute over all elements.
-     * @param keepdims - If true, reduced axes are left as dimensions with size 1
-     * @returns Quantile of array elements ignoring NaNs
-     */
-    nanquantile(q: number, axis?: number, keepdims?: boolean): NDArray | number;
-    /**
-     * Compute the q-th percentile of the data along the specified axis, ignoring NaNs
-     * @param q - Percentile to compute (0-100)
-     * @param axis - Axis along which to compute percentile. If undefined, compute over all elements.
-     * @param keepdims - If true, reduced axes are left as dimensions with size 1
-     * @returns Percentile of array elements ignoring NaNs
-     */
-    nanpercentile(q: number, axis?: number, keepdims?: boolean): NDArray | number;
-    /**
-     * Return the indices of the minimum values, ignoring NaNs
-     * @param axis - Axis along which to find minimum indices. If undefined, index of global minimum.
-     * @returns Indices of minimum values ignoring NaNs
-     */
-    nanargmin(axis?: number): NDArray | number;
-    /**
-     * Return the indices of the maximum values, ignoring NaNs
-     * @param axis - Axis along which to find maximum indices. If undefined, index of global maximum.
-     * @returns Indices of maximum values ignoring NaNs
-     */
-    nanargmax(axis?: number): NDArray | number;
-    /**
-     * Return the cumulative sum of elements, treating NaNs as zero
-     * @param axis - Axis along which to compute cumsum. If undefined, compute over flattened array.
-     * @returns Array with cumulative sums ignoring NaNs
-     */
-    nancumsum(axis?: number): NDArray;
-    /**
-     * Return the cumulative product of elements, treating NaNs as one
-     * @param axis - Axis along which to compute cumprod. If undefined, compute over flattened array.
-     * @returns Array with cumulative products ignoring NaNs
-     */
-    nancumprod(axis?: number): NDArray;
-    /**
-     * Compute the median, ignoring NaNs
-     * @param axis - Axis along which to compute median. If undefined, compute over all elements.
-     * @param keepdims - If true, reduced axes are left as dimensions with size 1
-     * @returns Median of array elements ignoring NaNs
-     */
-    nanmedian(axis?: number, keepdims?: boolean): NDArray | number;
-    /**
-     * Return a sorted copy of the array
-     * @param axis - Axis along which to sort. Default is -1 (last axis)
-     * @returns Sorted array
-     */
-    sort(axis?: number): NDArray;
-    /**
-     * Returns the indices that would sort this array
-     * @param axis - Axis along which to sort. Default is -1 (last axis)
-     * @returns Array of indices that sort the array
-     */
-    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)
-     * @returns Partitioned array
-     */
-    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)
-     * @returns Array of indices
-     */
-    argpartition(kth: number, axis?: number): NDArray;
-    /**
-     * Return the indices of non-zero elements
-     * @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
-     * @param side - 'left' or 'right' side to insert
-     * @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
-     * @param shape - New shape (must be compatible with current size)
-     * @returns Reshaped array
-     */
-    reshape(...shape: number[]): NDArray;
-    /**
-     * Return a flattened copy of the array
-     * @returns 1D array containing all elements
-     */
-    flatten(): NDArray;
-    /**
-     * Return a flattened array (view when possible, otherwise copy)
-     * @returns 1D array containing all elements
-     */
-    ravel(): 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. If undefined, squeeze all axes of length 1
-     * @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;
-    /**
-     * Repeat elements of an array
-     * @param repeats - Number of repetitions for each element
-     * @param axis - Axis along which to repeat (if undefined, flattens first)
-     * @returns New array with repeated elements
-     */
-    repeat(repeats: number | 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 (if undefined, flattens first)
-     * @returns New array with selected elements
-     */
-    take(indices: number[], axis?: number): 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;
-    /**
-     * Integer array indexing (fancy indexing)
-     *
-     * Select elements using an array of indices. This is NumPy's "fancy indexing"
-     * feature: `arr[[0, 2, 4]]` becomes `arr.iindex([0, 2, 4])` or `arr.iindex(indices)`.
-     *
-     * @param indices - Array of integer indices (as number[], NDArray, or nested arrays)
-     * @param axis - Axis along which to index (default: 0, or flattens if undefined with flat indices)
-     * @returns New array with selected elements
-     *
-     * @example
-     * ```typescript
-     * const arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]);
-     *
-     * // Select rows 0 and 2
-     * arr.iindex([0, 2]);           // [[1, 2, 3], [7, 8, 9]]
-     *
-     * // Select along axis 1 (columns)
-     * arr.iindex([0, 2], 1);        // [[1, 3], [4, 6], [7, 9]]
-     *
-     * // With NDArray indices
-     * const idx = np.array([0, 2]);
-     * arr.iindex(idx);              // [[1, 2, 3], [7, 8, 9]]
-     * ```
-     */
-    iindex(indices: NDArray | number[] | number[][], axis?: number): NDArray;
-    /**
-     * Boolean array indexing (fancy indexing with mask)
-     *
-     * Select elements where a boolean mask is true. This is NumPy's boolean
-     * indexing: `arr[arr > 5]` becomes `arr.bindex(arr.greater(5))`.
-     *
-     * @param mask - Boolean NDArray mask
-     * @param axis - Axis along which to apply the mask (default: flattens array)
-     * @returns New 1D array with selected elements (or along axis if specified)
-     *
-     * @example
-     * ```typescript
-     * const arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]);
-     *
-     * // Select all elements > 5
-     * const mask = arr.greater(5);
-     * arr.bindex(mask);             // [6, 7, 8, 9]
-     *
-     * // Select rows where first column > 3
-     * const rowMask = np.array([false, true, true]);
-     * arr.bindex(rowMask, 0);       // [[4, 5, 6], [7, 8, 9]]
-     * ```
-     */
-    bindex(mask: NDArray, axis?: number): NDArray;
-    /**
-     * Matrix multiplication
-     * @param other - Array to multiply with
-     * @returns Result of matrix multiplication
-     */
-    matmul(other: NDArray): NDArray;
-    /**
-     * Dot product (matching NumPy behavior)
-     * @param other - Array to dot with
-     * @returns Result of dot product (scalar or array depending on dimensions, Complex for complex arrays)
-     */
-    dot(other: NDArray): NDArray | number | bigint | Complex;
-    /**
-     * Sum of diagonal elements (trace)
-     * @returns Sum of diagonal elements (Complex for complex arrays)
-     */
-    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 (Complex for complex arrays)
-     */
-    inner(other: NDArray): NDArray | number | bigint | Complex;
-    /**
-     * Outer product (flattens inputs then computes a[i]*b[j])
-     * @param other - Array to compute outer product with
-     * @returns 2D outer product matrix
-     */
-    outer(other: NDArray): NDArray;
-    /**
-     * Tensor dot product along specified axes
-     * @param other - Array to contract with
-     * @param axes - Axes to contract (integer or [a_axes, b_axes])
-     * @returns Tensor dot product result
-     */
-    tensordot(other: NDArray, axes?: number | [number[], number[]]): NDArray | number | bigint | Complex;
-    /**
-     * Element-wise cube root
-     * Promotes integer types to float64
-     * @returns New array with cube root values
-     */
-    cbrt(): NDArray;
-    /**
-     * Element-wise absolute value (always returns float)
-     * @returns New array with absolute values as float
-     */
-    fabs(): NDArray;
-    /**
-     * 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];
-    /**
-     * Element-wise square (x**2)
-     * @returns New array with squared values
-     */
-    square(): NDArray;
-    /**
-     * Element-wise remainder (same as mod)
-     * @param divisor - Array or scalar divisor
-     * @returns New array with remainder values
-     */
-    remainder(divisor: NDArray | number): NDArray;
-    /**
-     * Heaviside step function
-     * @param x2 - Value to use when this array element is 0
-     * @returns New array with heaviside values
-     */
-    heaviside(x2: NDArray | number): 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;
-    /**
-     * 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 - use node.ts module for file operations)
-     */
-    tofile(_file: string, _sep?: string, _format?: string): void;
-}
-/**
- * Create array of zeros
- * @param shape - Shape of the array
- * @param dtype - Data type (default: float64)
- * @returns Array filled with zeros
- */
-export declare function zeros(shape: number[], dtype?: DType): NDArray;
-/**
- * Create array of ones
- * @param shape - Shape of the array
- * @param dtype - Data type (default: float64)
- * @returns Array filled with ones
- */
-export declare function ones(shape: number[], dtype?: DType): NDArray;
-/**
- * Create array from nested JavaScript arrays
- * @param data - Nested arrays or existing NDArray
- * @param dtype - Data type (optional, will be inferred if not provided)
- * @returns New NDArray
- */
-export declare function array(data: any, dtype?: DType): NDArray;
-/**
- * Create array with evenly spaced values within a given interval
- * Similar to Python's range() but returns array
- * @param start - Start value (or stop if only one argument)
- * @param stop - Stop value (exclusive)
- * @param step - Step between values (default: 1)
- * @param dtype - Data type (default: float64)
- * @returns Array of evenly spaced values
- */
-export declare function arange(start: number, stop?: number, step?: number, dtype?: DType): NDArray;
-/**
- * Create array with evenly spaced values over a specified interval
- * @param start - Starting value
- * @param stop - Ending value (inclusive)
- * @param num - Number of samples (default: 50)
- * @param dtype - Data type (default: float64)
- * @returns Array of evenly spaced values
- */
-export declare function linspace(start: number, stop: number, num?: number, dtype?: DType): NDArray;
-/**
- * Create array with logarithmically spaced values
- * Returns num samples, equally spaced on a log scale from base^start to base^stop
- * @param start - base^start is the starting value
- * @param stop - base^stop is the ending value
- * @param num - Number of samples (default: 50)
- * @param base - Base of the log space (default: 10.0)
- * @param dtype - Data type (default: float64)
- * @returns Array of logarithmically spaced values
- */
-export declare function logspace(start: number, stop: number, num?: number, base?: number, dtype?: DType): NDArray;
-/**
- * Create array with geometrically spaced values
- * Returns num samples, equally spaced on a log scale (geometric progression)
- * @param start - Starting value
- * @param stop - Ending value
- * @param num - Number of samples (default: 50)
- * @param dtype - Data type (default: float64)
- * @returns Array of geometrically spaced values
- */
-export declare function geomspace(start: number, stop: number, num?: number, dtype?: DType): NDArray;
-/**
- * Create identity matrix
- * @param n - Number of rows
- * @param m - Number of columns (default: n)
- * @param k - Index of diagonal (0 for main diagonal, positive for upper, negative for lower)
- * @param dtype - Data type (default: float64)
- * @returns Identity matrix
- */
-export declare function eye(n: number, m?: number, k?: number, dtype?: DType): NDArray;
-/**
- * Create an uninitialized array
- * Note: TypedArrays are zero-initialized by default in JavaScript
- * @param shape - Shape of the array
- * @param dtype - Data type (default: float64)
- * @returns Uninitialized array
- */
-export declare function empty(shape: number[], dtype?: DType): NDArray;
-/**
- * Create array filled with a constant value
- * @param shape - Shape of the array
- * @param fill_value - Value to fill the array with
- * @param dtype - Data type (optional, inferred from fill_value if not provided)
- * @returns Array filled with the constant value
- */
-export declare function full(shape: number[], fill_value: number | bigint | boolean, dtype?: DType): NDArray;
-/**
- * Create a square identity matrix
- * @param n - Size of the square matrix
- * @param dtype - Data type (default: float64)
- * @returns n×n identity matrix
- */
-export declare function identity(n: number, dtype?: DType): NDArray;
-/**
- * Convert input to an ndarray
- * @param a - Input data (array-like or NDArray)
- * @param dtype - Data type (optional)
- * @returns NDArray representation of the input
- */
-export declare function asarray(a: NDArray | any, dtype?: DType): NDArray;
-/**
- * Convert input to an array, checking for NaN and Inf values.
- * @param a - Input data
- * @param dtype - Data type (optional)
- * @returns NDArray
- * @throws If array contains NaN or Inf values
- */
-export declare function asarray_chkfinite(a: NDArray | ArrayLike<number | bigint>, dtype?: DType): NDArray;
-/**
- * Return array satisfying requirements.
- * @param a - Input array
- * @param dtype - Data type (optional)
- * @param requirements - Requirements ('C', 'F', 'A', 'W', 'O', 'E') (optional)
- * @returns Array satisfying requirements
- */
-export declare function require(a: NDArray, dtype?: DType, requirements?: string | string[]): NDArray;
-/**
- * Create a deep copy of an array
- * @param a - Array to copy
- * @returns Deep copy of the array
- */
-export declare function copy(a: NDArray): NDArray;
-/**
- * Create array of zeros with the same shape as another array
- * @param a - Array to match shape from
- * @param dtype - Data type (optional, uses a's dtype if not provided)
- * @returns Array of zeros
- */
-export declare function zeros_like(a: NDArray, dtype?: DType): NDArray;
-/**
- * Create array of ones with the same shape as another array
- * @param a - Array to match shape from
- * @param dtype - Data type (optional, uses a's dtype if not provided)
- * @returns Array of ones
- */
-export declare function ones_like(a: NDArray, dtype?: DType): NDArray;
-/**
- * Create uninitialized array with the same shape as another array
- * @param a - Array to match shape from
- * @param dtype - Data type (optional, uses a's dtype if not provided)
- * @returns Uninitialized array
- */
-export declare function empty_like(a: NDArray, dtype?: DType): NDArray;
-/**
- * Create array filled with a constant value, same shape as another array
- * @param a - Array to match shape from
- * @param fill_value - Value to fill with
- * @param dtype - Data type (optional, uses a's dtype if not provided)
- * @returns Filled array
- */
-export declare function full_like(a: NDArray, fill_value: number | bigint | boolean, dtype?: DType): NDArray;
-/**
- * Convert input to an ndarray (alias for asarray for compatibility)
- * In numpy-ts, this behaves the same as asarray since we don't have subclasses
- * @param a - Input data
- * @param dtype - Data type (optional)
- * @returns NDArray
- */
-export declare function asanyarray(a: NDArray | any, dtype?: DType): NDArray;
-/**
- * Return a contiguous array (ndim >= 1) in memory (C order)
- * Since our arrays are already C-contiguous in memory, this either
- * returns the input unchanged or creates a contiguous copy
- * @param a - Input data
- * @param dtype - Data type (optional)
- * @returns Contiguous array in C order
- */
-export declare function ascontiguousarray(a: NDArray | any, dtype?: DType): NDArray;
-/**
- * Return an array laid out in Fortran order in memory
- * Note: numpy-ts uses C-order internally, so this creates a copy
- * that is equivalent to the Fortran-ordered layout
- * @param a - Input data
- * @param dtype - Data type (optional)
- * @returns Array (copy in C order, as Fortran order is not supported)
- */
-export declare function asfortranarray(a: NDArray | any, dtype?: DType): NDArray;
-/**
- * Extract a diagonal or construct a diagonal array
- * @param v - Input array (if 2D, extract diagonal; if 1D, construct diagonal matrix)
- * @param k - Diagonal offset (default 0 is main diagonal, positive above, negative below)
- * @returns Diagonal elements as 1D array, or 2D diagonal matrix
- */
-export declare function diag(v: NDArray, k?: number): NDArray;
-/**
- * Create a 2-D array with the flattened input as a diagonal
- * @param v - Input array (will be flattened)
- * @param k - Diagonal offset (default 0)
- * @returns 2D diagonal matrix
- */
-export declare function diagflat(v: NDArray, k?: number): NDArray;
-/**
- * Construct an array by executing a function over each coordinate
- * @param fn - Function that takes coordinate indices and returns value
- * @param shape - Shape of output array
- * @param dtype - Data type (default: float64)
- * @returns Array with values computed from function
- */
-export declare function fromfunction(fn: (...indices: number[]) => number | bigint | boolean, shape: number[], dtype?: DType): 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[];
-/**
- * An array with ones at and below the given diagonal and zeros elsewhere
- * @param N - Number of rows
- * @param M - Number of columns (default: N)
- * @param k - Diagonal offset (default 0)
- * @param dtype - Data type (default: float64)
- * @returns Triangular array
- */
-export declare function tri(N: number, M?: number, k?: number, dtype?: DType): NDArray;
-/**
- * Lower triangle of an array
- * @param m - Input array
- * @param k - Diagonal above which to zero elements (default 0)
- * @returns Copy with upper triangle zeroed
- */
-export declare function tril(m: NDArray, k?: number): NDArray;
-/**
- * Upper triangle of an array
- * @param m - Input array
- * @param k - Diagonal below which to zero elements (default 0)
- * @returns Copy with lower triangle zeroed
- */
-export declare function triu(m: NDArray, k?: number): NDArray;
-/**
- * Generate a Vandermonde matrix
- * @param x - Input 1D array
- * @param N - Number of columns (default: length of x)
- * @param increasing - Order of powers (default: false, highest powers first)
- * @returns Vandermonde matrix
- */
-export declare function vander(x: NDArray, N?: number, increasing?: boolean): NDArray;
-/**
- * Interpret a buffer as a 1-dimensional array
- * @param buffer - Buffer-like object (ArrayBuffer, TypedArray, or DataView)
- * @param dtype - Data type (default: float64)
- * @param count - Number of items to read (-1 means all)
- * @param offset - Start reading from this byte offset
- * @returns NDArray from buffer data
- */
-export declare function frombuffer(buffer: ArrayBuffer | ArrayBufferView, dtype?: DType, count?: number, offset?: number): NDArray;
-/**
- * Construct an array by executing a function over each coordinate.
- * Note: This is a JS implementation - fromfile for actual files isn't directly applicable in browser JS.
- * This function creates an array from an iterable or callable.
- * @param file - In JS context, this is an iterable yielding values
- * @param dtype - Data type
- * @param count - Number of items to read (-1 means all)
- * @returns NDArray from the iterable
- */
-export declare function fromfile(file: Iterable<number | bigint>, dtype?: DType, count?: number): NDArray;
-/**
- * Create a new 1-dimensional array from an iterable object
- * @param iter - Iterable object
- * @param dtype - Data type
- * @param count - Number of items to read (-1 means all)
- * @returns NDArray from the iterable
- */
-export declare function fromiter(iter: Iterable<number | bigint>, dtype?: DType, count?: number): NDArray;
-/**
- * Create a new 1-dimensional array from text string
- * @param string - Input string containing numbers separated by whitespace or separator
- * @param dtype - Data type (default: float64)
- * @param count - Number of items to read (-1 means all)
- * @param sep - Separator between values (default: any whitespace)
- * @returns NDArray from parsed string
- */
-export declare function fromstring(string: string, dtype?: DType, count?: number, sep?: string): NDArray;
-/**
- * Element-wise square root
- * @param x - Input array
- * @returns Array of square roots
- */
-export declare function sqrt(x: NDArray): NDArray;
-/**
- * Element-wise power
- * @param x - Base array
- * @param exponent - Exponent (array or scalar)
- * @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
- * @returns Array of negated values
- */
-export declare function negative(x: NDArray): NDArray;
-/**
- * Element-wise sign (-1, 0, or 1)
- * @param x - Input array
- * @returns Array of signs
- */
-export declare function sign(x: NDArray): NDArray;
-/**
- * Element-wise modulo
- * @param x - Dividend array
- * @param divisor - Divisor (array or scalar)
- * @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
- * @param divisor - Divisor (array or scalar)
- * @returns Floor of the quotient
- */
-export declare function floor_divide(x: NDArray, divisor: NDArray | number): NDArray;
-/**
- * Element-wise positive (unary +)
- * @param x - Input array
- * @returns Copy of the array
- */
-export declare function positive(x: NDArray): NDArray;
-/**
- * Element-wise reciprocal (1/x)
- * @param x - Input array
- * @returns Array of reciprocals
- */
-export declare function reciprocal(x: NDArray): NDArray;
-/**
- * Dot product of two arrays
- *
- * Fully NumPy-compatible. Behavior depends on input dimensions:
- * - 0D · 0D: Multiply scalars → scalar
- * - 0D · ND or ND · 0D: Element-wise multiply → ND
- * - 1D · 1D: Inner product → scalar
- * - 2D · 2D: Matrix multiplication → 2D
- * - 2D · 1D: Matrix-vector product → 1D
- * - 1D · 2D: Vector-matrix product → 1D
- * - ND · 1D (N>2): Sum over last axis → (N-1)D
- * - 1D · ND (N>2): Sum over first axis → (N-1)D
- * - ND · MD (N,M≥2): Tensor contraction → (N+M-2)D
- *
- * @param a - First array
- * @param b - Second array
- * @returns Result of dot product (Complex for complex arrays)
- */
-export declare function dot(a: NDArray, b: NDArray): NDArray | number | bigint | Complex;
-/**
- * Sum of diagonal elements
- *
- * @param a - Input 2D array
- * @returns Sum of diagonal elements (Complex for complex arrays)
- */
-export declare function trace(a: NDArray): number | bigint | Complex;
-/**
- * Extract a diagonal from a matrix or N-D array
- *
- * @param a - Input array (must be at least 2D)
- * @param offset - Offset of the diagonal from the main diagonal (default: 0)
- * @param axis1 - First axis (default: 0)
- * @param axis2 - Second axis (default: 1)
- * @returns Array containing the diagonal elements
- */
-export declare function diagonal(a: NDArray, offset?: number, axis1?: number, axis2?: number): NDArray;
-/**
- * Kronecker product of two arrays
- *
- * @param a - First input array
- * @param b - Second input array
- * @returns Kronecker product of a and b
- */
-export declare function kron(a: NDArray, b: NDArray): NDArray;
-/**
- * Permute array dimensions
- *
- * @param a - Input array
- * @param axes - Optional permutation of axes (defaults to reverse order)
- * @returns Transposed view
- */
-export declare function transpose(a: NDArray, axes?: number[]): NDArray;
-/**
- * Inner product of two arrays
- *
- * Contracts over last axes of both arrays.
- * Result shape: (*a.shape[:-1], *b.shape[:-1])
- *
- * @param a - First array
- * @param b - Second array
- * @returns Inner product result (Complex for complex arrays)
- */
-export declare function inner(a: NDArray, b: NDArray): NDArray | number | bigint | Complex;
-/**
- * Outer product of two arrays
- *
- * Flattens inputs then computes result[i,j] = a[i] * b[j]
- *
- * @param a - First array
- * @param b - Second array
- * @returns 2D outer product matrix
- */
-export declare function outer(a: NDArray, b: NDArray): NDArray;
-/**
- * Tensor dot product along specified axes
- *
- * @param a - First array
- * @param b - Second array
- * @param axes - Axes to contract (integer or [a_axes, b_axes])
- * @returns Tensor dot product
- */
-export declare function tensordot(a: NDArray, b: NDArray, axes?: number | [number[], number[]]): NDArray | number | bigint | Complex;
-/**
- * Element-wise sine
- * @param x - Input array (angles in radians)
- * @returns Array of sine values
- */
-export declare function sin(x: NDArray): NDArray;
-/**
- * Element-wise cosine
- * @param x - Input array (angles in radians)
- * @returns Array of cosine values
- */
-export declare function cos(x: NDArray): NDArray;
-/**
- * Element-wise tangent
- * @param x - Input array (angles in radians)
- * @returns Array of tangent values
- */
-export declare function tan(x: NDArray): NDArray;
-/**
- * Element-wise inverse sine
- * @param x - Input array (values in range [-1, 1])
- * @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
- * @param x2 - x-coordinates (array or scalar)
- * @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
- * @param x1 - First leg
- * @param x2 - Second leg (array or scalar)
- * @returns Hypotenuse values
- */
-export declare function hypot(x1: NDArray, x2: NDArray | number): NDArray;
-/**
- * Convert angles from radians to degrees
- * @param x - Input array (angles in radians)
- * @returns Angles in degrees
- */
-export declare function degrees(x: NDArray): NDArray;
-/**
- * Convert angles from degrees to radians
- * @param x - Input array (angles in degrees)
- * @returns Angles in radians
- */
-export declare function radians(x: NDArray): NDArray;
-/**
- * Convert angles from degrees to radians (alias for radians)
- * @param x - Input array (angles in degrees)
- * @returns Angles in radians
- */
-export declare function deg2rad(x: NDArray): NDArray;
-/**
- * Convert angles from radians to degrees (alias for degrees)
- * @param x - Input array (angles in radians)
- * @returns Angles in degrees
- */
-export declare function rad2deg(x: NDArray): NDArray;
-/**
- * Element-wise hyperbolic sine
- * @param x - Input array
- * @returns Array of sinh values
- */
-export declare function sinh(x: NDArray): NDArray;
-/**
- * Element-wise hyperbolic cosine
- * @param x - Input array
- * @returns Array of cosh values
- */
-export declare function cosh(x: NDArray): NDArray;
-/**
- * Element-wise hyperbolic tangent
- * @param x - Input array
- * @returns Array of tanh values
- */
-export declare function tanh(x: NDArray): NDArray;
-/**
- * Element-wise inverse hyperbolic sine
- * @param x - Input array
- * @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
- *
- * @param a - Input array
- * @param axis1 - First axis
- * @param axis2 - Second axis
- * @returns View with axes swapped
- */
-export declare function swapaxes(a: NDArray, axis1: number, axis2: number): NDArray;
-/**
- * Move axes to new positions
- *
- * @param a - Input array
- * @param source - Original positions of axes to move
- * @param destination - New positions for axes
- * @returns View with axes moved
- */
-export declare function moveaxis(a: NDArray, source: number | number[], destination: number | number[]): NDArray;
-/**
- * Concatenate arrays along an existing axis
- *
- * @param arrays - Arrays to concatenate
- * @param axis - Axis along which to concatenate (default: 0)
- * @returns Concatenated array
- */
-export declare function concatenate(arrays: NDArray[], axis?: number): NDArray;
-/**
- * Stack arrays along a new axis
- *
- * @param arrays - Arrays to stack (must have same shape)
- * @param axis - Axis in the result array along which to stack (default: 0)
- * @returns Stacked array
- */
-export declare function stack(arrays: NDArray[], axis?: number): NDArray;
-/**
- * Stack arrays vertically (row-wise)
- *
- * @param arrays - Arrays to stack
- * @returns Vertically stacked array
- */
-export declare function vstack(arrays: NDArray[]): NDArray;
-/**
- * Stack arrays horizontally (column-wise)
- *
- * @param arrays - Arrays to stack
- * @returns Horizontally stacked array
- */
-export declare function hstack(arrays: NDArray[]): NDArray;
-/**
- * Stack arrays depth-wise (along third axis)
- *
- * @param arrays - Arrays to stack
- * @returns Depth-stacked array
- */
-export declare function dstack(arrays: NDArray[]): NDArray;
-/**
- * Join a sequence of arrays along an existing axis (alias for concatenate)
- */
-export declare function concat(arrays: NDArray[], axis?: number): NDArray;
-/**
- * Split an array into a sequence of sub-arrays along an axis (inverse of stack)
- */
-export declare function unstack(a: NDArray, axis?: number): NDArray[];
-/**
- * Assemble an nd-array from nested lists of blocks
- */
-export declare function block(arrays: NDArray[]): NDArray;
-/**
- * Split array into multiple sub-arrays
- *
- * @param a - Array to split
- * @param indicesOrSections - Number of equal sections or indices where to split
- * @param axis - Axis along which to split (default: 0)
- * @returns List of sub-arrays
- */
-export declare function split(a: NDArray, indicesOrSections: number | number[], axis?: number): NDArray[];
-/**
- * Split array into multiple sub-arrays (allows unequal splits)
- *
- * @param a - Array to split
- * @param indicesOrSections - Number of sections or indices where to split
- * @param axis - Axis along which to split (default: 0)
- * @returns List of sub-arrays
- */
-export declare function array_split(a: NDArray, indicesOrSections: number | number[], axis?: number): NDArray[];
-/**
- * Split array vertically (row-wise)
- *
- * @param a - Array to split
- * @param indicesOrSections - Number of sections or indices where to split
- * @returns List of sub-arrays
- */
-export declare function vsplit(a: NDArray, indicesOrSections: number | number[]): NDArray[];
-/**
- * Split array horizontally (column-wise)
- *
- * @param a - Array to split
- * @param indicesOrSections - Number of sections or indices where to split
- * @returns List of sub-arrays
- */
-export declare function hsplit(a: NDArray, indicesOrSections: number | number[]): NDArray[];
-/**
- * Tile array by repeating along each axis
- *
- * @param a - Input array
- * @param reps - Number of repetitions along each axis
- * @returns Tiled array
- */
-export declare function tile(a: NDArray, reps: number | number[]): NDArray;
-/**
- * Repeat elements of an array
- *
- * @param a - Input array
- * @param repeats - Number of repetitions for each element
- * @param axis - Axis along which to repeat (if undefined, flattens first)
- * @returns Array with repeated elements
- */
-export declare function repeat(a: NDArray, repeats: number | number[], axis?: number): NDArray;
-/**
- * Return a contiguous flattened array
- *
- * @param a - Input array
- * @returns Flattened 1-D array (view if possible)
- */
-export declare function ravel(a: NDArray): NDArray;
-/**
- * Return a copy of the array collapsed into one dimension
- */
-export declare function flatten(a: NDArray): NDArray;
-/**
- * Fill the array with a scalar value (in-place)
- */
-export declare function fill(a: NDArray, value: number | bigint): void;
-/**
- * Copy an element of an array to a standard scalar and return it
- */
-export declare function item(a: NDArray, ...args: number[]): number | bigint | Complex;
-/**
- * Return the array as a nested list
- */
-export declare function tolist(a: NDArray): any;
-/**
- * Return the raw bytes of the array data
- */
-export declare function tobytes(a: NDArray): ArrayBuffer;
-/**
- * Swap the bytes of the array elements
- */
-export declare function byteswap(a: NDArray, inplace?: boolean): NDArray;
-/**
- * New view of array with the same data
- */
-export declare function view(a: NDArray, dtype?: DType): NDArray;
-/**
- * Write array to a file as text or binary
- */
-export declare function tofile(a: NDArray, file: string, sep?: string, format?: string): void;
-/**
- * Reshape array to new shape
- *
- * @param a - Input array
- * @param newShape - New shape
- * @returns Reshaped array (view if possible)
- */
-export declare function reshape(a: NDArray, newShape: number[]): NDArray;
-/**
- * Remove axes of length 1
- *
- * @param a - Input array
- * @param axis - Axis to squeeze (optional, squeezes all if not specified)
- * @returns Squeezed array (view)
- */
-export declare function squeeze(a: NDArray, axis?: number): NDArray;
-/**
- * Expand the shape of an array by inserting a new axis
- *
- * @param a - Input array
- * @param axis - Position where new axis should be inserted
- * @returns Array with expanded shape (view)
- */
-export declare function expand_dims(a: NDArray, axis: number): NDArray;
-/**
- * Reverse the order of elements along the given axis
- *
- * @param m - Input array
- * @param axis - Axis or axes to flip (flips all if undefined)
- * @returns Flipped array
- */
-export declare function flip(m: NDArray, axis?: number | number[]): NDArray;
-/**
- * Flip array in the left/right direction (reverse along axis 1)
- *
- * @param m - Input array (must be at least 2-D)
- * @returns Flipped array
- */
-export declare function fliplr(m: NDArray): NDArray;
-/**
- * Flip array in the up/down direction (reverse along axis 0)
- *
- * @param m - Input array (must be at least 2-D)
- * @returns Flipped array
- */
-export declare function flipud(m: NDArray): NDArray;
-/**
- * Rotate array by 90 degrees
- *
- * @param m - Input array
- * @param k - Number of times to rotate (default 1)
- * @param axes - The axes to rotate in (default [0, 1])
- * @returns Rotated array
- */
-export declare function rot90(m: NDArray, k?: number, axes?: [number, number]): NDArray;
-/**
- * Roll array elements along a given axis
- *
- * @param a - Input array
- * @param shift - Number of positions to shift
- * @param axis - Axis along which to roll (rolls flattened array if undefined)
- * @returns Rolled array
- */
-export declare function roll(a: NDArray, shift: number | number[], axis?: number | number[]): NDArray;
-/**
- * Roll the specified axis backwards until it lies in a given position
- *
- * @param a - Input array
- * @param axis - The axis to roll backwards
- * @param start - Position to roll to (default 0)
- * @returns Array with rolled axis (view)
- */
-export declare function rollaxis(a: NDArray, axis: number, start?: number): NDArray;
-/**
- * Convert inputs to arrays with at least 1 dimension
- *
- * @param arrays - Input arrays
- * @returns Arrays with at least 1 dimension
- */
-export declare function atleast_1d(...arrays: NDArray[]): NDArray | NDArray[];
-/**
- * Convert inputs to arrays with at least 2 dimensions
- *
- * @param arrays - Input arrays
- * @returns Arrays with at least 2 dimensions
- */
-export declare function atleast_2d(...arrays: NDArray[]): NDArray | NDArray[];
-/**
- * Convert inputs to arrays with at least 3 dimensions
- *
- * @param arrays - Input arrays
- * @returns Arrays with at least 3 dimensions
- */
-export declare function atleast_3d(...arrays: NDArray[]): NDArray | NDArray[];
-/**
- * Split array along third axis (depth)
- *
- * @param ary - Input array (must be at least 3-D)
- * @param indices_or_sections - Number of sections or indices where to split
- * @returns List of sub-arrays
- */
-export declare function dsplit(ary: NDArray, indices_or_sections: number | number[]): NDArray[];
-/**
- * Stack 1-D arrays as columns into a 2-D array
- *
- * @param arrays - 1-D arrays to stack
- * @returns 2-D array with inputs as columns
- */
-export declare function column_stack(arrays: NDArray[]): NDArray;
-/**
- * Stack arrays in sequence vertically (alias for vstack)
- *
- * @param arrays - Arrays to stack
- * @returns Vertically stacked array
- */
-export declare function row_stack(arrays: NDArray[]): NDArray;
-/**
- * Return a new array with the given shape (repeating data if needed)
- *
- * @param a - Input array
- * @param new_shape - New shape
- * @returns Resized array
- */
-export declare function resize(a: NDArray, new_shape: number[]): NDArray;
-/**
- * Append values to the end of an array
- *
- * @param arr - Input array
- * @param values - Values to append
- * @param axis - Axis along which to append (flattens if undefined)
- * @returns Array with values appended
- */
-export declare function append(arr: NDArray, values: NDArray | ArrayLike<number | bigint> | number, axis?: number): NDArray;
-/**
- * Return a new array with sub-arrays along an axis deleted
- *
- * @param arr - Input array
- * @param obj - Indices to delete
- * @param axis - Axis along which to delete (flattens if undefined)
- * @returns Array with elements deleted
- */
-export declare function delete_(arr: NDArray, obj: number | number[], axis?: number): NDArray;
-/**
- * Insert values along the given axis before the given indices
- *
- * @param arr - Input array
- * @param obj - Index before which to insert
- * @param values - Values to insert
- * @param axis - Axis along which to insert (flattens if undefined)
- * @returns Array with values inserted
- */
-export declare function insert(arr: NDArray, obj: number, values: NDArray | ArrayLike<number | bigint> | number, axis?: number): NDArray;
-/**
- * Pad an array
- *
- * @param array - Input array
- * @param pad_width - Number of values padded to edges of each axis
- * @param mode - Padding mode ('constant', 'edge', 'reflect', 'symmetric', 'wrap')
- * @param constant_values - Value for constant padding (default 0)
- * @returns Padded array
- */
-export declare function pad(arr: NDArray, pad_width: number | [number, number] | Array<[number, number]>, mode?: 'constant' | 'edge' | 'reflect' | 'symmetric' | 'wrap', constant_values?: number): NDArray;
-/**
- * Broadcast an array to a given shape
- *
- * @param a - Input array
- * @param shape - Target shape
- * @returns View broadcast to target shape
- */
-export declare function broadcast_to(a: NDArray, shape: number[]): NDArray;
-/**
- * Broadcast arrays to a common shape
- *
- * @param arrays - Arrays to broadcast
- * @returns Arrays broadcast to common shape
- */
-export declare function broadcast_arrays(...arrays: NDArray[]): NDArray[];
-/**
- * Compute the broadcast shape for multiple shapes
- *
- * Returns the resulting shape if all shapes are broadcast-compatible.
- * Throws an error if shapes are not broadcast-compatible.
- *
- * @param shapes - Variable number of shapes to broadcast
- * @returns The broadcast output shape
- * @throws Error if shapes are not broadcast-compatible
- */
-export declare function broadcast_shapes(...shapes: number[][]): number[];
-/**
- * Take elements from an array along an axis
- *
- * @param a - Input array
- * @param indices - Indices of elements to take
- * @param axis - Axis along which to take (if undefined, flattens first)
- * @returns Array with selected elements
- */
-export declare function take(a: NDArray, indices: number[], axis?: number): NDArray;
-/**
- * Put values at specified indices (modifies array in-place)
- *
- * @param a - Target array
- * @param indices - Indices at which to place values
- * @param values - Values to put
- */
-export declare function put(a: NDArray, indices: number[], values: NDArray | number | bigint): void;
-/**
- * Integer array indexing (fancy indexing)
- *
- * Select elements from an array using an array of indices.
- * NumPy equivalent: `arr[[0, 2, 4]]`
- *
- * @param a - Input array
- * @param indices - Array of integer indices (as number[], NDArray, or nested arrays)
- * @param axis - Axis along which to index (default: 0)
- * @returns New array with selected elements
- *
- * @example
- * ```typescript
- * const arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]);
- * np.iindex(arr, [0, 2]);      // [[1, 2, 3], [7, 8, 9]]
- * np.iindex(arr, [0, 2], 1);   // [[1, 3], [4, 6], [7, 9]]
- * ```
- */
-export declare function iindex(a: NDArray, indices: NDArray | number[] | number[][], axis?: number): NDArray;
-/**
- * Boolean array indexing (fancy indexing with mask)
- *
- * Select elements from an array where a boolean mask is true.
- * NumPy equivalent: `arr[arr > 5]`
- *
- * @param a - Input array
- * @param mask - Boolean NDArray mask
- * @param axis - Axis along which to apply the mask (default: flattens array)
- * @returns New array with selected elements
- *
- * @example
- * ```typescript
- * const arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]);
- * const mask = arr.greater(5);
- * np.bindex(arr, mask);        // [6, 7, 8, 9]
- * ```
- */
-export declare function bindex(a: NDArray, mask: NDArray, axis?: number): NDArray;
-/**
- * Copy values from one array to another, broadcasting as necessary.
- *
- * @param dst - Destination array (modified in-place)
- * @param src - Source array or scalar
- * @param where - Optional boolean array. Only copy where True (not yet implemented)
- * @throws Error if shapes are not broadcastable
- *
- * @example
- * ```typescript
- * const dst = np.zeros([3, 3]);
- * const src = np.array([1, 2, 3]);
- * np.copyto(dst, src);  // Each row of dst becomes [1, 2, 3]
- * ```
- */
-export declare function copyto(dst: NDArray, src: NDArray | number | bigint, where?: NDArray): void;
-/**
- * Construct array from index array and choices
- *
- * @param a - Index array (integer indices into choices)
- * @param choices - Arrays to choose from
- * @returns Array constructed from choices
- */
-export declare function choose(a: NDArray, choices: NDArray[]): NDArray;
-/**
- * Check if two arrays are element-wise equal
- *
- * @param a - First array
- * @param b - Second array
- * @param equal_nan - Whether to consider NaN equal to NaN (default: false)
- * @returns True if arrays are equal element-wise
- */
-export declare function array_equal(a: NDArray, b: NDArray, equal_nan?: boolean): boolean;
-/**
- * Returns True if two arrays are element-wise equal within a tolerance.
- * Unlike array_equal, this function broadcasts the arrays before comparison.
- *
- * @param a1 - First input array
- * @param a2 - Second input array
- * @returns True if arrays are equivalent (after broadcasting)
- */
-export declare function array_equiv(a1: NDArray, a2: NDArray): boolean;
-/**
- * Return the cumulative sum of the elements along a given axis.
- * @param a - Input array
- * @param axis - Axis along which to compute. If undefined, flattened array is used.
- * @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
- * @param axis - Axis along which to compute. If undefined, flattened array is used.
- * @returns Array with cumulative products
- */
-export declare function cumprod(a: NDArray, axis?: number): NDArray;
-export { cumprod as cumulative_prod };
-/**
- * Return the maximum along a given axis.
- * @param a - Input array
- * @param axis - Axis along which to compute. If undefined, use all elements.
- * @param keepdims - If true, reduced axes are left as dimensions with size 1
- * @returns Maximum value(s)
- */
-export declare function max(a: NDArray, axis?: number, keepdims?: boolean): NDArray | number | Complex;
-export { max as amax };
-/**
- * Return the minimum along a given axis.
- * @param a - Input array
- * @param axis - Axis along which to compute. If undefined, use all elements.
- * @param keepdims - If true, reduced axes are left as dimensions with size 1
- * @returns Minimum value(s)
- */
-export declare function min(a: NDArray, axis?: number, keepdims?: boolean): NDArray | number | Complex;
-export { min as amin };
-/**
- * Peak to peak (maximum - minimum) value along a given axis.
- * @param a - Input array
- * @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 Peak to peak value(s)
- */
-export declare function ptp(a: NDArray, axis?: number, keepdims?: boolean): NDArray | number | Complex;
-/**
- * Compute the median along the specified 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 Median value(s)
- */
-export declare function median(a: NDArray, axis?: number, keepdims?: boolean): NDArray | number;
-/**
- * Compute the q-th percentile of the data along the specified axis.
- * @param a - Input array
- * @param q - Percentile (0-100)
- * @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 Percentile value(s)
- */
-export declare function percentile(a: NDArray, q: number, axis?: number, keepdims?: boolean): NDArray | number;
-/**
- * Compute the q-th quantile of the data along the specified axis.
- * @param a - Input array
- * @param q - Quantile (0-1)
- * @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 Quantile value(s)
- */
-export declare function quantile(a: NDArray, q: number, axis?: number, keepdims?: boolean): NDArray | number;
-/**
- * Compute the weighted average along the specified axis.
- * @param a - Input array
- * @param axis - Axis along which to compute. If undefined, use all elements.
- * @param weights - Array of weights (must be same shape as array along specified axis)
- * @param keepdims - If true, reduced axes are left as dimensions with size 1
- * @returns Weighted average value(s)
- */
-export declare function average(a: NDArray, axis?: number, weights?: NDArray, keepdims?: boolean): NDArray | number | Complex;
-/**
- * Return the sum of array elements over a given axis, treating NaNs as zero.
- * @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 Sum value(s)
- */
-export declare function nansum(a: NDArray, axis?: number, keepdims?: boolean): NDArray | number | Complex;
-/**
- * Return the product of array elements over a given axis, treating NaNs as one.
- * @param a - Input array
- * @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 Product value(s)
- */
-export declare function nanprod(a: NDArray, axis?: number, keepdims?: boolean): NDArray | number | Complex;
-/**
- * Compute the arithmetic mean along the specified axis, ignoring NaNs.
- * @param a - Input array
- * @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 Mean value(s)
- */
-export declare function nanmean(a: NDArray, axis?: number, keepdims?: boolean): NDArray | number | Complex;
-/**
- * Compute the variance along the specified axis, ignoring NaNs.
- * @param a - Input array
- * @param axis - Axis along which to compute. If undefined, use all elements.
- * @param ddof - Delta degrees of freedom (default 0)
- * @param keepdims - If true, reduced axes are left as dimensions with size 1
- * @returns Variance value(s)
- */
-export declare function nanvar(a: NDArray, axis?: number, ddof?: number, keepdims?: boolean): NDArray | number;
-/**
- * Compute the standard deviation along the specified axis, ignoring NaNs.
- * @param a - Input array
- * @param axis - Axis along which to compute. If undefined, use all elements.
- * @param ddof - Delta degrees of freedom (default 0)
- * @param keepdims - If true, reduced axes are left as dimensions with size 1
- * @returns Standard deviation value(s)
- */
-export declare function nanstd(a: NDArray, axis?: number, ddof?: number, keepdims?: boolean): NDArray | number;
-/**
- * Return minimum of an array, ignoring NaNs.
- * @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 nanmin(a: NDArray, axis?: number, keepdims?: boolean): NDArray | number | Complex;
-/**
- * Return maximum of an array, ignoring NaNs.
- * @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 nanmax(a: NDArray, axis?: number, keepdims?: boolean): NDArray | number | Complex;
-/**
- * Return indices of the minimum value, ignoring NaNs.
- * @param a - Input array
- * @param axis - Axis along which to compute. If undefined, use flattened array.
- * @returns Index/indices of minimum value(s)
- */
-export declare function nanargmin(a: NDArray, axis?: number): NDArray | number;
-/**
- * Return indices of the maximum value, ignoring NaNs.
- * @param a - Input array
- * @param axis - Axis along which to compute. If undefined, use flattened array.
- * @returns Index/indices of maximum value(s)
- */
-export declare function nanargmax(a: NDArray, axis?: number): NDArray | number;
-/**
- * Return cumulative sum of elements, treating NaNs as zero.
- * @param a - Input array
- * @param axis - Axis along which to compute. If undefined, use flattened array.
- * @returns Array with cumulative sums
- */
-export declare function nancumsum(a: NDArray, axis?: number): NDArray;
-/**
- * Return cumulative product of elements, treating NaNs as one.
- * @param a - Input array
- * @param axis - Axis along which to compute. If undefined, use flattened array.
- * @returns Array with cumulative products
- */
-export declare function nancumprod(a: NDArray, axis?: number): NDArray;
-/**
- * Compute the median, ignoring NaNs.
- * @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 Median value(s)
- */
-export declare function nanmedian(a: NDArray, axis?: number, keepdims?: boolean): NDArray | number;
-/**
- * Compute the q-th quantile of data along specified axis, ignoring NaNs
- */
-export declare function nanquantile(a: NDArray, q: number, axis?: number, keepdims?: boolean): NDArray | number;
-/**
- * Compute the q-th percentile of data along specified axis, ignoring NaNs
- */
-export declare function nanpercentile(a: NDArray, q: number, axis?: number, keepdims?: boolean): NDArray | number;
-/**
- * Element-wise cube root
- *
- * @param x - Input array
- * @returns Array with cube root of each element
- */
-export declare function cbrt(x: NDArray): NDArray;
-/**
- * Element-wise absolute value (always returns float)
- *
- * @param x - Input array
- * @returns Array with absolute values as float
- */
-export declare function fabs(x: NDArray): NDArray;
-/**
- * Returns both quotient and remainder (floor divide and modulo)
- *
- * @param x - Dividend array
- * @param y - Divisor (array or scalar)
- * @returns Tuple of [quotient, remainder] arrays
- */
-export declare function divmod(x: NDArray, y: NDArray | number): [NDArray, NDArray];
-/**
- * Element-wise square (x**2)
- *
- * @param x - Input array
- * @returns Array with squared values
- */
-export declare function square(x: NDArray): NDArray;
-/**
- * Element-wise remainder (same as mod)
- *
- * @param x - Dividend array
- * @param y - Divisor (array or scalar)
- * @returns Array with remainder values
- */
-export declare function remainder(x: NDArray, y: NDArray | number): NDArray;
-/**
- * Heaviside step function
- *
- * @param x1 - Input array
- * @param x2 - Value to use when x1 is 0
- * @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];
-/**
- * Clip (limit) the values in an array.
- *
- * Given an interval, values outside the interval are clipped to the interval edges.
- *
- * @param a - Input array
- * @param a_min - Minimum value (null to not clip minimum)
- * @param a_max - Maximum value (null to not clip maximum)
- * @returns Clipped array
- */
-export declare function clip(a: NDArray, a_min: NDArray | number | null, a_max: NDArray | number | null): NDArray;
-/**
- * Element-wise maximum of array elements.
- *
- * Compare two arrays and return a new array containing the element-wise maxima.
- * If one of the elements being compared is a NaN, then that element is returned.
- *
- * @param x1 - First input array
- * @param x2 - Second input array or scalar
- * @returns Element-wise maximum
- */
-export declare function maximum(x1: NDArray, x2: NDArray | number): NDArray;
-/**
- * Element-wise minimum of array elements.
- *
- * Compare two arrays and return a new array containing the element-wise minima.
- * If one of the elements being compared is a NaN, then that element is returned.
- *
- * @param x1 - First input array
- * @param x2 - Second input array or scalar
- * @returns Element-wise minimum
- */
-export declare function minimum(x1: NDArray, x2: NDArray | number): NDArray;
-/**
- * Element-wise maximum of array elements, ignoring NaNs.
- *
- * Compare two arrays and return a new array containing the element-wise maxima.
- * If one of the values being compared is a NaN, the other is returned.
- *
- * @param x1 - First input array
- * @param x2 - Second input array or scalar
- * @returns Element-wise maximum, NaN-aware
- */
-export declare function fmax(x1: NDArray, x2: NDArray | number): NDArray;
-/**
- * Element-wise minimum of array elements, ignoring NaNs.
- *
- * Compare two arrays and return a new array containing the element-wise minima.
- * If one of the values being compared is a NaN, the other is returned.
- *
- * @param x1 - First input array
- * @param x2 - Second input array or scalar
- * @returns Element-wise minimum, NaN-aware
- */
-export declare function fmin(x1: NDArray, x2: NDArray | number): NDArray;
-/**
- * Replace NaN with zero and Inf with large finite numbers.
- *
- * @param x - Input array
- * @param nan - Value to replace NaN (default: 0.0)
- * @param posinf - Value to replace positive infinity (default: largest finite)
- * @param neginf - Value to replace negative infinity (default: most negative finite)
- * @returns Array with replacements
- */
-export declare function nan_to_num(x: NDArray, nan?: number, posinf?: number, neginf?: number): NDArray;
-/**
- * One-dimensional linear interpolation.
- *
- * Returns the one-dimensional piecewise linear interpolant to a function
- * with given discrete data points (xp, fp), evaluated at x.
- *
- * @param x - The x-coordinates at which to evaluate the interpolated values
- * @param xp - The x-coordinates of the data points (must be increasing)
- * @param fp - The y-coordinates of the data points
- * @param left - Value for x < xp[0] (default: fp[0])
- * @param right - Value for x > xp[-1] (default: fp[-1])
- * @returns Interpolated values
- */
-export declare function interp(x: NDArray, xp: NDArray, fp: NDArray, left?: number, right?: number): NDArray;
-/**
- * Unwrap by changing deltas between values to 2*pi complement.
- *
- * Unwrap radian phase p by changing absolute jumps greater than
- * discont to their 2*pi complement along the given axis.
- *
- * @param p - Input array of phase angles in radians
- * @param discont - Maximum discontinuity between values (default: pi)
- * @param axis - Axis along which to unwrap (default: -1, last axis)
- * @param period - Size of the range over which the input wraps (default: 2*pi)
- * @returns Unwrapped array
- */
-export declare function unwrap(p: NDArray, discont?: number, axis?: number, period?: number): NDArray;
-/**
- * Return the normalized sinc function.
- *
- * sinc(x) = sin(pi*x) / (pi*x)
- *
- * The sinc function is 1 at x = 0, and sin(pi*x)/(pi*x) otherwise.
- *
- * @param x - Input array
- * @returns Array of sinc values
- */
-export declare function sinc(x: NDArray): NDArray;
-/**
- * Modified Bessel function of the first kind, order 0.
- *
- * @param x - Input array
- * @returns Array of I0 values
- */
-export declare function i0(x: NDArray): NDArray;
-/**
- * Bitwise AND element-wise
- *
- * @param x1 - First input array (must be integer type)
- * @param x2 - Second input array or scalar (must be integer type)
- * @returns Result of bitwise AND
- */
-export declare function bitwise_and(x1: NDArray, x2: NDArray | number): NDArray;
-/**
- * Bitwise OR element-wise
- *
- * @param x1 - First input array (must be integer type)
- * @param x2 - Second input array or scalar (must be integer type)
- * @returns Result of bitwise OR
- */
-export declare function bitwise_or(x1: NDArray, x2: NDArray | number): NDArray;
-/**
- * Bitwise XOR element-wise
- *
- * @param x1 - First input array (must be integer type)
- * @param x2 - Second input array or scalar (must be integer type)
- * @returns Result of bitwise XOR
- */
-export declare function bitwise_xor(x1: NDArray, x2: NDArray | number): NDArray;
-/**
- * Bitwise NOT (inversion) element-wise
- *
- * @param x - Input array (must be integer type)
- * @returns Result of bitwise NOT
- */
-export declare function bitwise_not(x: NDArray): NDArray;
-/**
- * Invert (bitwise NOT) element-wise
- * Alias for bitwise_not
- *
- * @param x - Input array (must be integer type)
- * @returns Result of bitwise inversion
- */
-export declare function invert(x: NDArray): NDArray;
-/**
- * Left shift elements by positions
- *
- * @param x1 - Input array (must be integer type)
- * @param x2 - Shift amount (array or scalar)
- * @returns Result of left shift
- */
-export declare function left_shift(x1: NDArray, x2: NDArray | number): NDArray;
-/**
- * Right shift elements by positions
- *
- * @param x1 - Input array (must be integer type)
- * @param x2 - Shift amount (array or scalar)
- * @returns Result of right shift
- */
-export declare function right_shift(x1: NDArray, x2: NDArray | number): NDArray;
-/**
- * Pack binary values into uint8 array
- *
- * Packs the elements of a binary-valued array into bits in a uint8 array.
- *
- * @param a - Input array (values are interpreted as binary: 0 or non-zero)
- * @param axis - The dimension over which bit-packing is done (default: -1)
- * @param bitorder - Order of bits: 'big' or 'little' (default: 'big')
- * @returns Packed uint8 array
- */
-export declare function packbits(a: NDArray, axis?: number, bitorder?: 'big' | 'little'): NDArray;
-/**
- * Unpack uint8 array into binary values
- *
- * Unpacks elements of a uint8 array into a binary-valued output array.
- *
- * @param a - Input uint8 array
- * @param axis - The dimension over which bit-unpacking is done (default: -1)
- * @param count - Number of elements to unpack, or -1 for all (default: -1)
- * @param bitorder - Order of bits: 'big' or 'little' (default: 'big')
- * @returns Unpacked uint8 array of 0s and 1s
- */
-export declare function unpackbits(a: NDArray, axis?: number, count?: number, bitorder?: 'big' | 'little'): NDArray;
-/**
- * Count the number of 1-bits (population count) in each element.
- *
- * @param x - Input array (must be integer type)
- * @returns Array with population count for each element
- */
-export declare function bitwise_count(x: NDArray): NDArray;
-/**
- * Bitwise invert (alias for bitwise_not).
- *
- * @param x - Input array (must be integer type)
- * @returns Result with bitwise NOT values
- */
-export declare function bitwise_invert(x: NDArray): NDArray;
-/**
- * Bitwise left shift (alias for left_shift).
- *
- * @param x1 - Input array (must be integer type)
- * @param x2 - Shift amount (array or scalar)
- * @returns Result with left-shifted values
- */
-export declare function bitwise_left_shift(x1: NDArray, x2: NDArray | number): NDArray;
-/**
- * Bitwise right shift (alias for right_shift).
- *
- * @param x1 - Input array (must be integer type)
- * @param x2 - Shift amount (array or scalar)
- * @returns Result with right-shifted values
- */
-export declare function bitwise_right_shift(x1: NDArray, x2: NDArray | number): NDArray;
-/**
- * Logical AND element-wise
- *
- * Returns a boolean array where each element is the logical AND
- * of corresponding elements (non-zero = true, zero = false).
- *
- * @param x1 - First input array
- * @param x2 - Second input array or scalar
- * @returns Boolean result array
- */
-export declare function logical_and(x1: NDArray, x2: NDArray | number): NDArray;
-/**
- * Logical OR element-wise
- *
- * Returns a boolean array where each element is the logical OR
- * of corresponding elements (non-zero = true, zero = false).
- *
- * @param x1 - First input array
- * @param x2 - Second input array or scalar
- * @returns Boolean result array
- */
-export declare function logical_or(x1: NDArray, x2: NDArray | number): NDArray;
-/**
- * Logical NOT element-wise
- *
- * Returns a boolean array where each element is the logical NOT
- * of the input (non-zero = false, zero = true).
- *
- * @param x - Input array
- * @returns Boolean result array
- */
-export declare function logical_not(x: NDArray): NDArray;
-/**
- * Logical XOR element-wise
- *
- * Returns a boolean array where each element is the logical XOR
- * of corresponding elements (non-zero = true, zero = false).
- *
- * @param x1 - First input array
- * @param x2 - Second input array or scalar
- * @returns Boolean result array
- */
-export declare function logical_xor(x1: NDArray, x2: NDArray | number): NDArray;
-/**
- * Test element-wise for finiteness (not infinity and not NaN)
- *
- * @param x - Input array
- * @returns Boolean array where True means finite
- */
-export declare function isfinite(x: NDArray): NDArray;
-/**
- * Test element-wise for positive or negative infinity
- *
- * @param x - Input array
- * @returns Boolean array where True means infinite
- */
-export declare function isinf(x: NDArray): NDArray;
-/**
- * Test element-wise for NaN (Not a Number)
- *
- * @param x - Input array
- * @returns Boolean array where True means NaN
- */
-export declare function isnan(x: NDArray): NDArray;
-/**
- * Test element-wise for NaT (Not a Time)
- *
- * @param x - Input array
- * @returns Boolean array (always false without datetime support)
- */
-export declare function isnat(x: NDArray): NDArray;
-/**
- * Change the sign of x1 to that of x2, element-wise
- *
- * Returns a value with the magnitude of x1 and the sign of x2.
- *
- * @param x1 - Values to change sign of (magnitude source)
- * @param x2 - Values whose sign is used (sign source)
- * @returns Array with magnitude from x1 and sign from x2
- */
-export declare function copysign(x1: NDArray, x2: NDArray | number): NDArray;
-/**
- * Returns element-wise True where signbit is set (less than zero)
- *
- * @param x - Input array
- * @returns Boolean array where True means signbit is set
- */
-export declare function signbit(x: NDArray): NDArray;
-/**
- * Return the next floating-point value after x1 towards x2, element-wise
- *
- * @param x1 - Values to find the next representable value of
- * @param x2 - Direction to look for the next representable value
- * @returns Array of next representable values
- */
-export declare function nextafter(x1: NDArray, x2: NDArray | number): NDArray;
-/**
- * Return the distance between x and the nearest adjacent number
- *
- * @param x - Input array
- * @returns Array of spacing values
- */
-export declare function spacing(x: NDArray): NDArray;
-/**
- * Test element-wise for complex number.
- *
- * For complex arrays, returns true for elements with non-zero imaginary part.
- * For real arrays, always returns false.
- *
- * @param x - Input array
- * @returns Boolean array
- */
-export declare function iscomplex(x: NDArray): NDArray;
-/**
- * Check whether array is complex type.
- *
- * @param x - Input array
- * @returns true if dtype is complex64 or complex128
- */
-export declare function iscomplexobj(x: NDArray): boolean;
-/**
- * Test element-wise for real number (not complex).
- *
- * For complex arrays, returns true for elements with zero imaginary part.
- * For real arrays, always returns true.
- *
- * @param x - Input array
- * @returns Boolean array
- */
-export declare function isreal(x: NDArray): NDArray;
-/**
- * Check whether array is real type (not complex).
- *
- * @param x - Input array
- * @returns true if dtype is NOT complex64 or complex128
- */
-export declare function isrealobj(x: NDArray): boolean;
-/**
- * Return the real part of complex argument.
- *
- * For complex arrays, returns the real components.
- * For real arrays, returns a copy of the input.
- *
- * @param x - Input array
- * @returns Array with real parts
- */
-export declare function real(x: NDArray): NDArray;
-/**
- * Return the imaginary part of complex argument.
- *
- * For complex arrays, returns the imaginary components.
- * For real arrays, returns zeros.
- *
- * @param x - Input array
- * @returns Array with imaginary parts
- */
-export declare function imag(x: NDArray): NDArray;
-/**
- * Return the complex conjugate.
- *
- * For complex arrays, negates the imaginary part: (a + bi) -> (a - bi)
- * For real arrays, returns a copy of the input.
- *
- * @param x - Input array
- * @returns Complex conjugate array
- */
-export declare function conj(x: NDArray): NDArray;
-export declare const conjugate: typeof conj;
-/**
- * Return the angle (phase) of complex argument.
- *
- * angle(z) = arctan2(imag(z), real(z))
- *
- * For real arrays, returns 0 for positive, pi for negative.
- *
- * @param x - Input array
- * @param deg - Return angle in degrees if true (default: false, returns radians)
- * @returns Array with angles in radians (or degrees)
- */
-export declare function angle(x: NDArray, deg?: boolean): NDArray;
-/**
- * Test element-wise for negative infinity
- * @param x - Input array
- * @returns Boolean array
- */
-export declare function isneginf(x: NDArray): NDArray;
-/**
- * Test element-wise for positive infinity
- * @param x - Input array
- * @returns Boolean array
- */
-export declare function isposinf(x: NDArray): NDArray;
-/**
- * Check if array is Fortran contiguous (column-major order)
- * @param x - Input array
- * @returns true if F-contiguous
- */
-export declare function isfortran(x: NDArray): boolean;
-/**
- * Returns array with complex parts close to zero set to real
- * Since numpy-ts doesn't support complex numbers, returns copy
- * @param x - Input array
- * @param tol - Tolerance
- * @returns Copy of input array
- */
-export declare function real_if_close(x: NDArray, tol?: number): NDArray;
-/**
- * Check if element is a scalar type
- * @param val - Value to check
- * @returns true if scalar
- */
-export declare function isscalar(val: unknown): boolean;
-/**
- * Check if object is iterable
- * @param obj - Object to check
- * @returns true if iterable
- */
-export declare function iterable(obj: unknown): boolean;
-/**
- * Check if dtype meets specified criteria
- * @param dtype - Dtype to check
- * @param kind - Kind of dtype ('b' bool, 'i' int, 'u' uint, 'f' float)
- * @returns true if dtype matches kind
- */
-export declare function isdtype(dtype: DType, kind: string): boolean;
-/**
- * Find the dtype that can represent both input dtypes
- * @param dtype1 - First dtype
- * @param dtype2 - Second dtype
- * @returns Promoted dtype
- */
-export declare function promote_types(dtype1: DType, dtype2: DType): DType;
-/**
- * Einstein summation convention
- *
- * Performs tensor contractions and reductions using Einstein notation.
- *
- * @param subscripts - Einstein summation subscripts (e.g., 'ij,jk->ik')
- * @param operands - Input arrays
- * @returns Result of the Einstein summation
- *
- * @example
- * // Matrix multiplication
- * einsum('ij,jk->ik', a, b)
- *
- * @example
- * // Inner product
- * einsum('i,i->', a, b)
- *
- * @example
- * // Trace
- * einsum('ii->', a)
- */
-export declare function einsum(subscripts: string, ...operands: NDArray[]): NDArray | number | bigint | Complex;
-/**
- * Return the dot product of two vectors (flattened).
- *
- * Unlike dot(), vdot flattens both inputs before computing the dot product.
- * For complex numbers, vdot uses the complex conjugate of the first argument.
- *
- * @param a - First input array (will be flattened)
- * @param b - Second input array (will be flattened)
- * @returns Scalar dot product
- */
-export declare function vdot(a: NDArray, b: NDArray): number | bigint | Complex;
-/**
- * Vector dot product along the last axis.
- *
- * Computes the dot product of vectors along the last axis of both inputs.
- * The last dimensions of a and b must match.
- *
- * @param a - First input array
- * @param b - Second input array
- * @param axis - Axis along which to compute (default: -1, meaning last axis)
- * @returns Result with last dimension removed
- */
-export declare function vecdot(a: NDArray, b: NDArray, axis?: number): NDArray | number | bigint | Complex;
-/**
- * Transpose the last two axes of an array.
- *
- * Equivalent to swapaxes(a, -2, -1) or transpose with axes that swap the last two.
- * For a 2D array, this is the same as transpose.
- *
- * @param a - Input array with at least 2 dimensions
- * @returns Array with last two axes transposed
- */
-export declare function matrix_transpose(a: NDArray): NDArray;
-/**
- * Permute the dimensions of an array.
- *
- * This is an alias for transpose to match the Array API standard.
- *
- * @param a - Input array
- * @param axes - Permutation of axes. If not specified, reverses the axes.
- * @returns Transposed array
- */
-export declare function permute_dims(a: NDArray, axes?: number[]): NDArray;
-/**
- * Matrix-vector multiplication.
- *
- * Computes the matrix-vector product over the last two axes of x1 and
- * the last axis of x2.
- *
- * @param x1 - First input array (matrix) with shape (..., M, N)
- * @param x2 - Second input array (vector) with shape (..., N)
- * @returns Result with shape (..., M)
- */
-export declare function matvec(x1: NDArray, x2: NDArray): NDArray;
-/**
- * Vector-matrix multiplication.
- *
- * Computes the vector-matrix product over the last axis of x1 and
- * the second-to-last axis of x2.
- *
- * @param x1 - First input array (vector) with shape (..., M)
- * @param x2 - Second input array (matrix) with shape (..., M, N)
- * @returns Result with shape (..., N)
- */
-export declare function vecmat(x1: NDArray, x2: NDArray): NDArray;
-/**
- * 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;
-    /**
-     * Return specified diagonals.
-     */
-    diagonal: (a: NDArray, offset?: number, axis1?: number, axis2?: number) => NDArray;
-    /**
-     * Matrix multiplication.
-     */
-    matmul: (a: NDArray, b: NDArray) => NDArray;
-    /**
-     * Transpose the last two axes of an array.
-     */
-    matrix_transpose: (a: NDArray) => NDArray;
-    /**
-     * Compute the dot product of two or more arrays.
-     */
-    multi_dot: (arrays: NDArray[]) => NDArray;
-    /**
-     * Outer product of two vectors.
-     */
-    outer: (a: NDArray, b: NDArray) => NDArray;
-    /**
-     * Compute sign and (natural) logarithm of the determinant.
-     */
-    slogdet: (a: NDArray) => {
-        sign: number;
-        logabsdet: number;
-    };
-    /**
-     * Compute singular values of a matrix.
-     */
-    svdvals: (a: NDArray) => NDArray;
-    /**
-     * Tensor dot product along specified axes.
-     */
-    tensordot: (a: NDArray, b: NDArray, axes?: number | [number[], number[]]) => NDArray | number | bigint | Complex;
-    /**
-     * Compute the tensor inverse.
-     */
-    tensorinv: (a: NDArray, ind?: number) => NDArray;
-    /**
-     * Solve the tensor equation a x = b for x.
-     */
-    tensorsolve: (a: NDArray, b: NDArray, axes?: number[] | null) => NDArray;
-    /**
-     * Sum along diagonals.
-     */
-    trace: (a: NDArray) => number | bigint | Complex;
-    /**
-     * Vector dot product.
-     */
-    vecdot: (a: NDArray, b: NDArray, axis?: number) => NDArray | number | bigint | Complex;
-};
-/**
- * Take values from the input array by matching 1d index and data slices along axis.
- *
- * @param arr - Input array
- * @param indices - Index array with same ndim as arr
- * @param axis - The axis along which to select values
- * @returns Array of values taken along the axis
- */
-export declare function take_along_axis(arr: NDArray, indices: NDArray, axis: number): NDArray;
-/**
- * Put values into the destination array using 1d index and data slices along axis.
- *
- * @param arr - Destination array (modified in-place)
- * @param indices - Index array with same ndim as arr
- * @param values - Values to put
- * @param axis - The axis along which to put values
- */
-export declare function put_along_axis(arr: NDArray, indices: NDArray, values: NDArray, axis: number): void;
-/**
- * Change elements of array based on conditional mask.
- *
- * @param a - Array to modify (in-place)
- * @param mask - Boolean mask array
- * @param values - Values to put where mask is True
- */
-export declare function putmask(a: NDArray, mask: NDArray, values: NDArray | number | bigint): void;
-/**
- * Return selected slices of array along given axis.
- *
- * @param condition - Boolean array for selecting
- * @param a - Array from which to select
- * @param axis - Axis along which to select (if undefined, works on flattened array)
- * @returns Compressed array
- */
-export declare function compress(condition: NDArray, a: NDArray, axis?: number): NDArray;
-/**
- * Return an array drawn from elements in choicelist, depending on conditions.
- *
- * @param condlist - List of boolean arrays (conditions)
- * @param choicelist - List of arrays to choose from
- * @param defaultVal - Default value when no condition is met (default 0)
- * @returns Array with selected values
- */
-export declare function select(condlist: NDArray[], choicelist: NDArray[], defaultVal?: number | bigint): NDArray;
-/**
- * Change elements of an array based on conditional and input values.
- *
- * @param arr - Array to modify (in-place)
- * @param mask - Boolean mask array
- * @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.
- *
- * @param n - Size of arrays for which indices are returned
- * @param ndim - Number of dimensions (default 2)
- * @returns Tuple of index arrays
- */
-export declare function diag_indices(n: number, ndim?: number): NDArray[];
-/**
- * Return the indices to access the main diagonal of an n-dimensional array.
- *
- * @param arr - Input array (must have all equal dimensions)
- * @returns Tuple of index arrays
- */
-export declare function diag_indices_from(arr: NDArray): NDArray[];
-/**
- * Return the indices for the lower-triangle of an (n, m) array.
- *
- * @param n - Number of rows
- * @param k - Diagonal offset (0 = main, positive = above, negative = below)
- * @param m - Number of columns (default n)
- * @returns Tuple of row and column index arrays
- */
-export declare function tril_indices(n: number, k?: number, m?: number): NDArray[];
-/**
- * Return the indices for the lower-triangle of arr.
- *
- * @param arr - Input 2-D array
- * @param k - Diagonal offset (0 = main, positive = above, negative = below)
- * @returns Tuple of row and column index arrays
- */
-export declare function tril_indices_from(arr: NDArray, k?: number): NDArray[];
-/**
- * Return the indices for the upper-triangle of an (n, m) array.
- *
- * @param n - Number of rows
- * @param k - Diagonal offset (0 = main, positive = above, negative = below)
- * @param m - Number of columns (default n)
- * @returns Tuple of row and column index arrays
- */
-export declare function triu_indices(n: number, k?: number, m?: number): NDArray[];
-/**
- * Return the indices for the upper-triangle of arr.
- *
- * @param arr - Input 2-D array
- * @param k - Diagonal offset (0 = main, positive = above, negative = below)
- * @returns Tuple of row and column index arrays
- */
-export declare function triu_indices_from(arr: NDArray, k?: number): NDArray[];
-/**
- * Return the indices to access (n, n) arrays, given a masking function.
- *
- * @param n - The returned indices will be valid to access arrays of shape (n, n)
- * @param mask_func - A function that generates an (n, n) boolean mask
- * @param k - Optional diagonal offset passed to mask_func
- * @returns Tuple of row and column index arrays
- */
-export declare function mask_indices(n: number, mask_func: (n: number, k: number) => NDArray, k?: number): NDArray[];
-/**
- * Return an array representing the indices of a grid.
- *
- * @param dimensions - The shape of the grid
- * @param dtype - Data type of result (default 'int32')
- * @returns Array of shape (len(dimensions), *dimensions)
- */
-export declare function indices(dimensions: number[], dtype?: 'int32' | 'int64' | 'float64'): NDArray;
-/**
- * Construct an open mesh from multiple sequences.
- *
- * This function returns a list of arrays with shapes suitable for broadcasting.
- *
- * @param args - 1-D sequences
- * @returns Tuple of arrays for open mesh
- */
-export declare function ix_(...args: NDArray[]): NDArray[];
-/**
- * Convert a tuple of index arrays into an array of flat indices.
- *
- * @param multi_index - Tuple of index arrays
- * @param dims - Shape of array into which indices apply
- * @param mode - How to handle out-of-bounds indices ('raise', 'wrap', 'clip')
- * @returns Flattened indices
- */
-export declare function ravel_multi_index(multi_index: NDArray[], dims: number[], mode?: 'raise' | 'wrap' | 'clip'): NDArray;
-/**
- * Convert a flat index or array of flat indices into a tuple of coordinate arrays.
- *
- * @param indices - Array of indices or single index
- * @param shape - Shape of the array to index into
- * @param order - Row-major ('C') or column-major ('F') order
- * @returns Tuple of coordinate arrays
- */
-export declare function unravel_index(indices: NDArray | number, shape: number[], order?: 'C' | 'F'): NDArray[];
-/**
- * Return a sorted copy of an array
- * @param a - Input array
- * @param axis - Axis along which to sort. Default is -1 (last axis)
- * @returns Sorted array
- */
-export declare function sort(a: NDArray, axis?: number): NDArray;
-/**
- * Returns the indices that would sort an array
- * @param a - Input array
- * @param axis - Axis along which to sort. Default is -1 (last axis)
- * @returns Array of indices that sort the input array
- */
-export declare function argsort(a: NDArray, axis?: number): NDArray;
-/**
- * Perform an indirect stable sort using a sequence of keys
- * @param keys - Array of NDArrays, the last key is the primary sort key
- * @returns Array of indices that would sort the keys
- */
-export declare function lexsort(keys: NDArray[]): NDArray;
-/**
- * Partially sort an array
- * @param a - Input array
- * @param kth - Element index to partition by
- * @param axis - Axis along which to sort. Default is -1 (last axis)
- * @returns Partitioned array
- */
-export declare function partition(a: NDArray, kth: number, axis?: number): NDArray;
-/**
- * Returns indices that would partition an array
- * @param a - Input array
- * @param kth - Element index to partition by
- * @param axis - Axis along which to sort. Default is -1 (last axis)
- * @returns Array of indices
- */
-export declare function argpartition(a: NDArray, kth: number, axis?: number): NDArray;
-/**
- * Sort a complex array using the real part first, then the imaginary part
- * For real arrays, returns a sorted 1D array
- * @param a - Input array
- * @returns Sorted 1D array
- */
-export declare function sort_complex(a: NDArray): NDArray;
-/**
- * Return the indices of the elements that are non-zero
- * @param a - Input array
- * @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
- * @returns Array of indices
- */
-export declare function flatnonzero(a: NDArray): NDArray;
-/**
- * Return elements from x or y depending on condition
- * If only condition is given, returns indices where condition is true (like nonzero)
- * @param condition - Boolean array or condition
- * @param x - Values where condition is true (optional)
- * @param y - Values where condition is false (optional)
- * @returns Array with elements chosen from x or y, or indices if only condition given
- */
-export declare function where(condition: NDArray, x?: NDArray, y?: NDArray): NDArray | NDArray[];
-/**
- * Find indices where elements should be inserted to maintain order
- * @param a - Input array (must be sorted in ascending order)
- * @param v - Values to insert
- * @param side - 'left' or 'right' side to insert
- * @returns Indices where values should be inserted
- */
-export declare function searchsorted(a: NDArray, v: NDArray, side?: 'left' | 'right'): NDArray;
-/**
- * Return the elements of an array that satisfy some condition
- * @param condition - Boolean array
- * @param a - Input array
- * @returns 1D array of elements where condition is true
- */
-export declare function extract(condition: NDArray, a: NDArray): NDArray;
-/**
- * Count number of non-zero values in the array
- * @param a - Input array
- * @param axis - Axis along which to count (optional)
- * @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;
-/**
- * Trim leading and/or trailing zeros from a 1-D array.
- *
- * @param filt - Input 1-D array
- * @param trim - 'fb' to trim front and back, 'f' for front only, 'b' for back only (default: 'fb')
- * @returns Trimmed array
- */
-export declare function trim_zeros(filt: NDArray, trim?: 'f' | 'b' | 'fb'): NDArray;
-/**
- * Find the unique elements of an array, returning all optional outputs.
- *
- * @param x - Input array (flattened for uniqueness)
- * @returns Object with values, indices, inverse_indices, and counts (all as NDArray)
- */
-export declare function unique_all(x: NDArray): {
-    values: NDArray;
-    indices: NDArray;
-    inverse_indices: NDArray;
-    counts: NDArray;
-};
-/**
- * Find the unique elements of an array and their counts.
- *
- * @param x - Input array (flattened for uniqueness)
- * @returns Object with values and counts (both as NDArray)
- */
-export declare function unique_counts(x: NDArray): {
-    values: NDArray;
-    counts: NDArray;
-};
-/**
- * Find the unique elements of an array and their inverse indices.
- *
- * @param x - Input array (flattened for uniqueness)
- * @returns Object with values and inverse_indices (both as NDArray)
- */
-export declare function unique_inverse(x: NDArray): {
-    values: NDArray;
-    inverse_indices: NDArray;
-};
-/**
- * Find the unique elements of an array (values only).
- *
- * This is equivalent to unique(x) but with a clearer name for the Array API.
- *
- * @param x - Input array (flattened for uniqueness)
- * @returns Array of unique values, sorted
- */
-export declare function unique_values(x: 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;
-/**
- * Compute the edges of the bins for histogram.
- *
- * This function computes the bin edges without computing the histogram itself.
- *
- * @param a - Input data (flattened if not 1D)
- * @param bins - Number of bins (default: 10) or a string specifying the bin algorithm
- * @param range - Lower and upper range of bins. If not provided, uses [a.min(), a.max()]
- * @param weights - Optional weights for each data point (used for some algorithms)
- * @returns Array of bin edges (length = bins + 1)
- */
-export declare function histogram_bin_edges(a: NDArray, bins?: number | 'auto' | 'fd' | 'doane' | 'scott' | 'stone' | 'rice' | 'sturges' | 'sqrt', range?: [number, number], weights?: NDArray): NDArray;
-/**
- * Integrate along the given axis using the composite trapezoidal rule.
- *
- * @param y - Input array to integrate
- * @param x - Optional sample points corresponding to y values. If not provided, spacing is assumed to be 1.
- * @param dx - Spacing between sample points when x is not given (default: 1.0)
- * @param axis - The axis along which to integrate (default: -1, meaning last axis)
- * @returns Definite integral approximated using the composite trapezoidal rule
- */
-export declare function trapezoid(y: NDArray, x?: NDArray, dx?: number, axis?: number): NDArray | number;
-/**
- * Apply a function along a given axis.
- *
- * @param func1d - Function that takes a 1D array and returns a scalar or array
- * @param axis - Axis along which to apply the function
- * @param arr - Input array
- * @returns Result array
- */
-export declare function apply_along_axis(func1d: (arr: NDArray) => NDArray | number, axis: number, arr: NDArray): NDArray;
-/**
- * Apply a function over multiple axes.
- *
- * @param func - Function that operates on an array along an axis
- * @param a - Input array
- * @param axes - Axes over which to apply the function
- * @returns Result array
- */
-export declare function apply_over_axes(func: (a: NDArray, axis: number) => NDArray, a: NDArray, axes: number[]): NDArray;
-/**
- * Check if two arrays may share memory.
- *
- * @param a - First array
- * @param b - Second array
- * @returns True if arrays may share memory
- */
-export declare function may_share_memory(a: NDArray, b: NDArray): boolean;
-/**
- * Check if two arrays share memory.
- *
- * @param a - First array
- * @param b - Second array
- * @returns True if arrays share memory
- */
-export declare function shares_memory(a: NDArray, b: NDArray): boolean;
-/**
- * Return the number of dimensions of an array.
- *
- * @param a - Input array
- * @returns Number of dimensions
- */
-export declare function ndim(a: NDArray | number | unknown[] | unknown): number;
-/**
- * Return the shape of an array.
- *
- * @param a - Input array
- * @returns Shape tuple
- */
-export declare function shape(a: NDArray | number | unknown[] | unknown): number[];
-/**
- * Return the number of elements in an array.
- *
- * @param a - Input array
- * @returns Number of elements
- */
-export declare function size(a: NDArray | number | unknown[] | unknown): number;
-export { geterr, seterr, type FloatErrorState } from '../ops/advanced';
-/**
- * Casting rules for safe type conversion
- * In 'safe' mode: casting is allowed only if the value can be represented without loss
- * In 'same_kind': same kind of types allowed (e.g., float to float, int to int)
- * In 'unsafe': any conversion is allowed
- */
-type CastingRule = 'no' | 'equiv' | 'safe' | 'same_kind' | 'unsafe';
-/**
- * Returns true if cast between data types can occur according to the casting rule.
- *
- * @param from_dtype - Data type to cast from
- * @param to_dtype - Data type to cast to
- * @param casting - Casting rule: 'no', 'equiv', 'safe', 'same_kind', or 'unsafe'
- * @returns Whether the cast is allowed
- *
- * @example
- * ```typescript
- * can_cast('int32', 'float64')  // true - safe upcast
- * can_cast('float64', 'int32')  // false - would lose precision
- * can_cast('float64', 'int32', 'unsafe')  // true - forced cast
- * ```
- */
-export declare function can_cast(from_dtype: DType | NDArray, to_dtype: DType, casting?: CastingRule): boolean;
-/**
- * Return a scalar type which is common to the input arrays.
- *
- * The return type will always be an inexact (floating point) type, even if
- * all the input arrays are integer types.
- *
- * @param arrays - Input arrays
- * @returns Common scalar type ('float32' or 'float64', or complex variants)
- *
- * @example
- * ```typescript
- * const a = array([1, 2], { dtype: 'int32' });
- * const b = array([3.0, 4.0], { dtype: 'float32' });
- * common_type(a, b)  // 'float32'
- * ```
- */
-export declare function common_type(...arrays: NDArray[]): DType;
-/**
- * Returns the type that results from applying the NumPy type promotion rules
- * to the arguments.
- *
- * @param arrays_and_dtypes - A mix of arrays or dtype strings
- * @returns The result dtype
- *
- * @example
- * ```typescript
- * result_type('int32', 'float32')  // 'float64'
- * result_type(array([1, 2], { dtype: 'int8' }), 'float32')  // 'float32'
- * ```
- */
-export declare function result_type(...arrays_and_dtypes: (NDArray | DType)[]): DType;
-/**
- * For scalar val, returns the data type with the smallest size and smallest
- * scalar kind which can hold its value.
- *
- * @param val - Scalar value
- * @returns Minimum dtype to represent the value
- *
- * @example
- * ```typescript
- * min_scalar_type(10)   // 'uint8'
- * min_scalar_type(1000) // 'uint16'
- * min_scalar_type(-1)   // 'int8'
- * min_scalar_type(3.14) // 'float64'
- * ```
- */
-export declare function min_scalar_type(val: number | bigint | boolean): DType;
-/**
- * Returns true if first argument is a typecode lower/equal in type hierarchy.
- *
- * In NumPy, issubdtype checks if dtype1 is a subtype of dtype2.
- * For specific types (not categories), types are only subtypes of themselves.
- *
- * @param dtype1 - First dtype to check
- * @param dtype2 - Second dtype (or type category string)
- * @returns Whether dtype1 is a subtype of dtype2
- *
- * @example
- * ```typescript
- * issubdtype('int32', 'int32')      // true - same type
- * issubdtype('int32', 'int64')      // false - different types
- * issubdtype('int32', 'integer')    // true - int32 is an integer type
- * issubdtype('float32', 'floating') // true - float32 is a floating type
- * ```
- */
-export declare function issubdtype(dtype1: DType | NDArray, dtype2: DType | string): boolean;
-/**
- * Return a description for the given data type code.
- *
- * @param dtype - Data type to describe
- * @returns Human-readable description
- *
- * @example
- * ```typescript
- * typename('float64')  // 'float64'
- * typename('int32')    // 'int32'
- * ```
- */
-export declare function typename(dtype: DType): string;
-/**
- * Return the character for the minimum-size type to which given types can be
- * safely cast.
- *
- * @param typechars - String of type characters
- * @param typeset - Which set of types to consider: 'GDFgdf' (default)
- * @param default_dtype - Default type if no valid types found
- * @returns Type character for minimum safe type
- *
- * @example
- * ```typescript
- * mintypecode('if')  // 'd' (float64)
- * mintypecode('ff')  // 'f' (float32)
- * ```
- */
-export declare function mintypecode(typechars: string, typeset?: string, default_dtype?: string): string;
-/**
- * Find the coefficients of a polynomial with the given sequence of roots.
- *
- * Returns the coefficients of the polynomial whose leading coefficient is one
- * for the given sequence of zeros (multiple roots must be included in the
- * sequence as many times as their multiplicity).
- *
- * @param seq_of_zeros - Sequence of polynomial roots
- * @returns Array of polynomial coefficients, highest power first
- *
- * @example
- * ```typescript
- * poly([1, 2, 3])  // array([1, -6, 11, -6]) = (x-1)(x-2)(x-3)
- * poly([0, 0, 0])  // array([1, 0, 0, 0]) = x^3
- * ```
- */
-export declare function poly(seq_of_zeros: NDArray | number[]): NDArray;
-/**
- * Find the sum of two polynomials.
- *
- * @param a1 - First polynomial coefficients (highest power first)
- * @param a2 - Second polynomial coefficients (highest power first)
- * @returns Sum polynomial coefficients
- *
- * @example
- * ```typescript
- * polyadd([1, 2], [3, 4, 5])  // array([3, 5, 7])
- * ```
- */
-export declare function polyadd(a1: NDArray | number[], a2: NDArray | number[]): NDArray;
-/**
- * Return the derivative of the specified order of a polynomial.
- *
- * @param p - Polynomial coefficients (highest power first)
- * @param m - Order of the derivative (default: 1)
- * @returns Derivative polynomial coefficients
- *
- * @example
- * ```typescript
- * polyder([3, 2, 1])  // array([6, 2]) - derivative of 3x^2 + 2x + 1
- * polyder([4, 3, 2, 1], 2)  // array([24, 6]) - second derivative
- * ```
- */
-export declare function polyder(p: NDArray | number[], m?: number): NDArray;
-/**
- * Returns the quotient and remainder of polynomial division.
- *
- * @param u - Dividend polynomial coefficients (highest power first)
- * @param v - Divisor polynomial coefficients (highest power first)
- * @returns Tuple [quotient, remainder]
- *
- * @example
- * ```typescript
- * polydiv([1, -3, 2], [1, -1])  // [array([1, -2]), array([0])]
- * // (x^2 - 3x + 2) / (x - 1) = (x - 2) with remainder 0
- * ```
- */
-export declare function polydiv(u: NDArray | number[], v: NDArray | number[]): [NDArray, NDArray];
-/**
- * Least squares polynomial fit.
- *
- * Fit a polynomial p(x) = p[0] * x^deg + ... + p[deg] of degree deg to points (x, y).
- *
- * @param x - x-coordinates of the sample points
- * @param y - y-coordinates of the sample points
- * @param deg - Degree of the fitting polynomial
- * @returns Polynomial coefficients, highest power first
- *
- * @example
- * ```typescript
- * const x = array([0, 1, 2, 3, 4]);
- * const y = array([0, 1, 4, 9, 16]);
- * polyfit(x, y, 2)  // approximately array([1, 0, 0]) for y = x^2
- * ```
- */
-export declare function polyfit(x: NDArray, y: NDArray, deg: number): NDArray;
-/**
- * Return an antiderivative (indefinite integral) of a polynomial.
- *
- * @param p - Polynomial coefficients (highest power first)
- * @param m - Order of the antiderivative (default: 1)
- * @param k - Integration constants (default: 0)
- * @returns Antiderivative polynomial coefficients
- *
- * @example
- * ```typescript
- * polyint([3, 2, 1])  // array([1, 1, 1, 0]) - integral of 3x^2 + 2x + 1
- * polyint([6, 2], 1, 5)  // array([2, 1, 5]) - with constant 5
- * ```
- */
-export declare function polyint(p: NDArray | number[], m?: number, k?: number | number[]): NDArray;
-/**
- * Find the product of two polynomials.
- *
- * @param a1 - First polynomial coefficients (highest power first)
- * @param a2 - Second polynomial coefficients (highest power first)
- * @returns Product polynomial coefficients
- *
- * @example
- * ```typescript
- * polymul([1, 2], [1, 3])  // array([1, 5, 6]) = (x+2)(x+3)
- * ```
- */
-export declare function polymul(a1: NDArray | number[], a2: NDArray | number[]): NDArray;
-/**
- * Difference (subtraction) of two polynomials.
- *
- * @param a1 - First polynomial coefficients (highest power first)
- * @param a2 - Second polynomial coefficients (highest power first)
- * @returns Difference polynomial coefficients
- *
- * @example
- * ```typescript
- * polysub([1, 2, 3], [0, 1, 1])  // array([1, 1, 2])
- * ```
- */
-export declare function polysub(a1: NDArray | number[], a2: NDArray | number[]): NDArray;
-/**
- * Evaluate a polynomial at specific values.
- *
- * @param p - Polynomial coefficients (highest power first)
- * @param x - Values at which to evaluate the polynomial
- * @returns Polynomial values at x
- *
- * @example
- * ```typescript
- * polyval([1, -2, 1], 3)  // 4 = 3^2 - 2*3 + 1
- * polyval([1, 0, 0], array([1, 2, 3]))  // array([1, 4, 9])
- * ```
- */
-export declare function polyval(p: NDArray | number[], x: NDArray | number | number[]): NDArray | number;
-/**
- * Return the roots of a polynomial with coefficients given in p.
- *
- * The values in the rank-1 array p are coefficients of a polynomial.
- * If the length of p is n+1 then the polynomial is:
- * p[0]*x^n + p[1]*x^(n-1) + ... + p[n-1]*x + p[n]
- *
- * @param p - Polynomial coefficients (highest power first)
- * @returns Array of roots (may be complex, returned as numbers for real roots)
- *
- * @example
- * ```typescript
- * roots([1, -3, 2])  // array([2, 1]) - roots of x^2 - 3x + 2
- * roots([1, 0, -1])  // array([1, -1]) - roots of x^2 - 1
- * ```
- */
-export declare function roots(p: NDArray | number[]): NDArray;
-//# sourceMappingURL=ndarray.d.ts.map