numpy-ts 0.12.0 → 0.13.1

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

@@ -0,0 +1,603 @@
+import { NDArray } from './ndarray';
+import { NDArrayCore } from '../common/ndarray-core';
+import { Complex } from '../common/complex';
+import type { DType, TypedArray } from '../core/types';
+export type { DType, TypedArray } from '../core/types';
+export { NDArray, meshgrid } from './ndarray';
+export { NDArrayCore } from '../common/ndarray-core';
+export { Complex } from '../common/complex';
+/** Broadcast array to a new shape - returns a view */
+export declare function broadcast_to(a: NDArrayCore, shape: number[]): NDArray;
+export declare function take(a: NDArrayCore, indices: number[], axis?: number): NDArray;
+export declare function take_along_axis(arr: NDArrayCore, indices: NDArrayCore, axis: number): NDArray;
+export declare function choose(a: NDArrayCore, choices: NDArrayCore[]): NDArray;
+export declare function compress(condition: NDArrayCore, a: NDArrayCore, axis?: number): NDArray;
+/**
+ * Integer array indexing (fancy indexing)
+ *
+ * Select elements using an array of indices.
+ */
+export declare function iindex(a: NDArrayCore, indices: NDArrayCore | number[] | number[][], axis?: number): NDArray;
+/**
+ * Boolean array indexing (fancy indexing with mask)
+ *
+ * Select elements where a boolean mask is true.
+ */
+export declare function bindex(a: NDArrayCore, mask: NDArrayCore, axis?: number): NDArray;
+export declare function select(condlist: NDArrayCore[], choicelist: NDArrayCore[], defaultVal?: number): NDArray;
+export declare function indices(dimensions: number[], dtype?: 'int32' | 'int64' | 'float64'): NDArray;
+export declare function ravel_multi_index(multi_index: NDArrayCore[], dims: number[], mode?: 'raise' | 'wrap' | 'clip'): NDArray;
+export declare function unravel_index(indices: NDArrayCore | number, shape: number[]): NDArray[];
+export declare function diag_indices(n: number, ndim?: number): NDArray[];
+export declare function diag_indices_from(a: NDArrayCore): NDArray[];
+export declare function tril_indices(n: number, k?: number, m?: number): NDArray[];
+export declare function tril_indices_from(a: NDArrayCore, k?: number): NDArray[];
+export declare function triu_indices(n: number, k?: number, m?: number): NDArray[];
+export declare function triu_indices_from(a: NDArrayCore, k?: number): NDArray[];
+export declare function mask_indices(n: number, mask_func: (n: number, k: number) => NDArrayCore, k?: number): NDArray[];
+export declare function apply_along_axis(func1d: (arr: NDArrayCore) => NDArrayCore | number, axis: number, arr: NDArrayCore): NDArray;
+export declare function apply_over_axes(func: (arr: NDArrayCore, axis: number) => NDArrayCore, a: NDArrayCore, axes: number[]): NDArray;
+/** Add arguments element-wise */
+export declare function add(x1: NDArrayCore, x2: NDArrayCore | number): NDArray;
+/** Subtract arguments element-wise */
+export declare function subtract(x1: NDArrayCore, x2: NDArrayCore | number): NDArray;
+/** Multiply arguments element-wise */
+export declare function multiply(x1: NDArrayCore, x2: NDArrayCore | number): NDArray;
+/** Square root of array elements */
+export declare function sqrt(x: NDArrayCore): NDArray;
+/** Element-wise power */
+export declare function power(x: NDArrayCore, exponent: NDArrayCore | number): NDArray;
+/** Exponential (e^x) */
+export declare function exp(x: NDArrayCore): NDArray;
+/** 2^x */
+export declare function exp2(x: NDArrayCore): NDArray;
+/** exp(x) - 1 */
+export declare function expm1(x: NDArrayCore): NDArray;
+/** Natural logarithm */
+export declare function log(x: NDArrayCore): NDArray;
+/** Base-2 logarithm */
+export declare function log2(x: NDArrayCore): NDArray;
+/** Base-10 logarithm */
+export declare function log10(x: NDArrayCore): NDArray;
+/** log(1 + x) */
+export declare function log1p(x: NDArrayCore): NDArray;
+/** log(exp(x1) + exp(x2)) */
+export declare function logaddexp(x1: NDArrayCore, x2: NDArrayCore | number): NDArray;
+/** log2(2^x1 + 2^x2) */
+export declare function logaddexp2(x1: NDArrayCore, x2: NDArrayCore | number): NDArray;
+/** Absolute value */
+export declare function absolute(x: NDArrayCore): NDArray;
+/** Numerical negative */
+export declare function negative(x: NDArrayCore): NDArray;
+/** Element-wise sign */
+export declare function sign(x: NDArrayCore): NDArray;
+/** Element-wise modulo */
+export declare function mod(x: NDArrayCore, divisor: NDArrayCore | number): NDArray;
+/** Element-wise division */
+export declare function divide(x: NDArrayCore, divisor: NDArrayCore | number): NDArray;
+/** Element-wise floor division */
+export declare function floor_divide(x: NDArrayCore, divisor: NDArrayCore | number): NDArray;
+/** Numerical positive (returns copy) */
+export declare function positive(x: NDArrayCore): NDArray;
+/** Reciprocal (1/x) */
+export declare function reciprocal(x: NDArrayCore): NDArray;
+/** Cube root */
+export declare function cbrt(x: NDArrayCore): NDArray;
+/** Absolute value (float) */
+export declare function fabs(x: NDArrayCore): NDArray;
+/** Element-wise divmod (quotient and remainder) */
+export declare function divmod(x: NDArrayCore, y: NDArrayCore | number): [NDArray, NDArray];
+/** Element-wise square */
+export declare function square(x: NDArrayCore): NDArray;
+/** Element-wise remainder */
+export declare function remainder(x: NDArrayCore, y: NDArrayCore | number): NDArray;
+/** Heaviside step function */
+export declare function heaviside(x1: NDArrayCore, x2: NDArrayCore | number): NDArray;
+/** Float power (always returns float) */
+export declare function float_power(x1: NDArrayCore, x2: NDArrayCore | number): NDArray;
+/** C-style fmod */
+export declare function fmod(x1: NDArrayCore, x2: NDArrayCore | number): NDArray;
+/** Decompose into mantissa and exponent */
+export declare function frexp(x: NDArrayCore): [NDArray, NDArray];
+/** Greatest common divisor */
+export declare function gcd(x1: NDArrayCore, x2: NDArrayCore | number): NDArray;
+/** Least common multiple */
+export declare function lcm(x1: NDArrayCore, x2: NDArrayCore | number): NDArray;
+/** Compose from mantissa and exponent */
+export declare function ldexp(x1: NDArrayCore, x2: NDArrayCore | number): NDArray;
+/** Decompose into fractional and integer parts */
+export declare function modf(x: NDArrayCore): [NDArray, NDArray];
+/** Clip values to a range */
+export declare function clip(a: NDArrayCore, a_min: NDArrayCore | number | null, a_max: NDArrayCore | number | null): NDArray;
+/** Element-wise maximum */
+export declare function maximum(x1: NDArrayCore, x2: NDArrayCore | number): NDArray;
+/** Element-wise minimum */
+export declare function minimum(x1: NDArrayCore, x2: NDArrayCore | number): NDArray;
+/** Element-wise maximum (ignores NaN) */
+export declare function fmax(x1: NDArrayCore, x2: NDArrayCore | number): NDArray;
+/** Element-wise minimum (ignores NaN) */
+export declare function fmin(x1: NDArrayCore, x2: NDArrayCore | number): NDArray;
+/** Replace NaN/Inf with numbers */
+export declare function nan_to_num(x: NDArrayCore, nan?: number, posinf?: number, neginf?: number): NDArray;
+/** 1D linear interpolation */
+export declare function interp(x: NDArrayCore, xp: NDArrayCore, fp: NDArrayCore, left?: number, right?: number): NDArray;
+/** Unwrap phase angles */
+export declare function unwrap(p: NDArrayCore, discont?: number, axis?: number, period?: number): NDArray;
+/** Sinc function */
+export declare function sinc(x: NDArrayCore): NDArray;
+/** Modified Bessel function of the first kind, order 0 */
+export declare function i0(x: NDArrayCore): NDArray;
+/** Bitwise AND */
+export declare function bitwise_and(x1: NDArrayCore, x2: NDArrayCore | number): NDArray;
+/** Bitwise OR */
+export declare function bitwise_or(x1: NDArrayCore, x2: NDArrayCore | number): NDArray;
+/** Bitwise XOR */
+export declare function bitwise_xor(x1: NDArrayCore, x2: NDArrayCore | number): NDArray;
+/** Bitwise NOT */
+export declare function bitwise_not(x: NDArrayCore): NDArray;
+/** Bitwise inversion (alias for bitwise_not) */
+export declare function invert(x: NDArrayCore): NDArray;
+/** Left shift */
+export declare function left_shift(x1: NDArrayCore, x2: NDArrayCore | number): NDArray;
+/** Right shift */
+export declare function right_shift(x1: NDArrayCore, x2: NDArrayCore | number): NDArray;
+/** Pack bits into bytes */
+export declare function packbits(a: NDArrayCore, axis?: number, bitorder?: 'big' | 'little'): NDArray;
+/** Unpack bytes into bits */
+export declare function unpackbits(a: NDArrayCore, axis?: number, count?: number, bitorder?: 'big' | 'little'): NDArray;
+/** Count number of 1 bits */
+export declare function bitwise_count(x: NDArrayCore): NDArray;
+/** Alias for bitwise_not */
+export declare function bitwise_invert(x: NDArrayCore): NDArray;
+/** Alias for left_shift */
+export declare function bitwise_left_shift(x1: NDArrayCore, x2: NDArrayCore | number): NDArray;
+/** Alias for right_shift */
+export declare function bitwise_right_shift(x1: NDArrayCore, x2: NDArrayCore | number): NDArray;
+/** Extract real part of array */
+export declare function real(x: NDArrayCore): NDArray;
+/** Extract imaginary part of array */
+export declare function imag(x: NDArrayCore): NDArray;
+/** Complex conjugate */
+export declare function conj(x: NDArrayCore): NDArray;
+/** Phase angle */
+export declare function angle(x: NDArrayCore, deg?: boolean): NDArray;
+/**
+ * Create array of zeros
+ */
+export declare function zeros(shape: number[], dtype?: DType): NDArray;
+/**
+ * Create array of ones
+ */
+export declare function ones(shape: number[], dtype?: DType): NDArray;
+/**
+ * Create an uninitialized array (zeros in JS)
+ */
+export declare function empty(shape: number[], dtype?: DType): NDArray;
+/**
+ * Create array filled with a constant value
+ */
+export declare function full(shape: number[], fill_value: number | bigint | boolean, dtype?: DType): NDArray;
+/**
+ * Create array from nested JavaScript arrays
+ */
+export declare function array(data: unknown, dtype?: DType): NDArray;
+/**
+ * Create array with evenly spaced values within a given interval
+ */
+export declare function arange(start: number, stop?: number, step?: number, dtype?: DType): NDArray;
+/**
+ * Create array with evenly spaced values over a specified interval
+ */
+export declare function linspace(start: number, stop: number, num?: number, dtype?: DType): NDArray;
+/**
+ * Create array with logarithmically spaced values
+ */
+export declare function logspace(start: number, stop: number, num?: number, base?: number, dtype?: DType): NDArray;
+/**
+ * Create array with geometrically spaced values
+ */
+export declare function geomspace(start: number, stop: number, num?: number, dtype?: DType): NDArray;
+/**
+ * Create identity matrix
+ */
+export declare function eye(n: number, m?: number, k?: number, dtype?: DType): NDArray;
+/**
+ * Create a square identity matrix
+ */
+export declare function identity(n: number, dtype?: DType): NDArray;
+/**
+ * Convert input to an ndarray
+ */
+export declare function asarray(a: NDArrayCore | unknown, dtype?: DType): NDArray;
+/**
+ * Return array of zeros with the same shape and dtype as input
+ */
+export declare function zeros_like(a: NDArrayCore, dtype?: DType): NDArray;
+/**
+ * Return array of ones with the same shape and dtype as input
+ */
+export declare function ones_like(a: NDArrayCore, dtype?: DType): NDArray;
+/**
+ * Return empty array with the same shape and dtype as input
+ */
+export declare function empty_like(a: NDArrayCore, dtype?: DType): NDArray;
+/**
+ * Return array filled with value, same shape and dtype as input
+ */
+export declare function full_like(a: NDArrayCore, fill_value: number | bigint | boolean, dtype?: DType): NDArray;
+/**
+ * Deep copy of array
+ */
+export declare function copy(a: NDArrayCore): NDArray;
+export declare function asanyarray(a: NDArrayCore | unknown, dtype?: DType): NDArray;
+export declare function ascontiguousarray(a: NDArrayCore | unknown, dtype?: DType): NDArray;
+export declare function asfortranarray(a: NDArrayCore | unknown, dtype?: DType): NDArray;
+export declare function asarray_chkfinite(a: NDArrayCore | unknown, dtype?: DType): NDArray;
+export declare function require(a: NDArrayCore, dtype?: DType, _requirements?: string | string[]): NDArray;
+export declare function diag(v: NDArrayCore, k?: number): NDArray;
+export declare function diagflat(v: NDArrayCore, k?: number): NDArray;
+export declare function tri(N: number, M?: number, k?: number, dtype?: DType): NDArray;
+export declare function tril(m: NDArrayCore, k?: number): NDArray;
+export declare function triu(m: NDArrayCore, k?: number): NDArray;
+export declare function vander(x: NDArrayCore, N?: number, increasing?: boolean): NDArray;
+export declare function frombuffer(buffer: ArrayBuffer | TypedArray, dtype?: DType, count?: number, offset?: number): NDArray;
+export declare function fromfunction(func: (...indices: number[]) => number, shape: number[], dtype?: DType): NDArray;
+export declare function fromiter(iter: Iterable<number>, dtype?: DType, count?: number): NDArray;
+export declare function fromstring(string: string, dtype?: DType, count?: number, sep?: string): NDArray;
+export declare function fromfile(_file: string, _dtype?: DType, _count?: number, _sep?: string): NDArray;
+/** Calculate n-th discrete difference */
+export declare function diff(a: NDArrayCore, n?: number, axis?: number): NDArray;
+/** Difference between consecutive elements in 1D array */
+export declare function ediff1d(a: NDArrayCore, to_end?: number[] | null, to_begin?: number[] | null): NDArray;
+/** Dot product of two arrays */
+export declare function dot(a: NDArrayCore, b: NDArrayCore): NDArray | number | bigint | Complex;
+/** Return diagonal or construct diagonal array */
+export declare function diagonal(a: NDArrayCore, offset?: number, axis1?: number, axis2?: number): NDArray;
+/** Kronecker product */
+export declare function kron(a: NDArrayCore, b: NDArrayCore): NDArray;
+/** Transpose array - returns a view */
+export declare function transpose(a: NDArrayCore, axes?: number[]): NDArray;
+/** Inner product of two arrays */
+export declare function inner(a: NDArrayCore, b: NDArrayCore): NDArray | number | bigint | Complex;
+/** Outer product of two arrays */
+export declare function outer(a: NDArrayCore, b: NDArrayCore): NDArray;
+/** Tensor dot product */
+export declare function tensordot(a: NDArrayCore, b: NDArrayCore, axes?: number | [number[], number[]]): NDArray | number | bigint | Complex;
+/** Vector dot product along specified axis */
+export declare function vecdot(x1: NDArrayCore, x2: NDArrayCore, axis?: number): NDArray | number | bigint | Complex;
+/** Matrix transpose (swap last two axes) */
+/** Matrix transpose - returns a view */
+export declare function matrix_transpose(a: NDArrayCore): NDArray;
+/** Permute array dimensions - returns a view */
+export declare function permute_dims(a: NDArrayCore, axes?: number[]): NDArray;
+/** Matrix-vector product */
+export declare function matvec(x1: NDArrayCore, x2: NDArrayCore): NDArray;
+/** Vector-matrix product */
+export declare function vecmat(x1: NDArrayCore, x2: NDArrayCore): NDArray;
+/** Cross product */
+export declare function cross(a: NDArrayCore, b: NDArrayCore, axisa?: number, axisb?: number, axisc?: number, axis?: number): NDArray;
+/** Matrix multiplication */
+export declare function matmul(a: NDArrayCore, b: NDArrayCore): NDArray;
+/** Element-wise logical AND */
+export declare function logical_and(x1: NDArrayCore, x2: NDArrayCore | number): NDArray;
+/** Element-wise logical OR */
+export declare function logical_or(x1: NDArrayCore, x2: NDArrayCore | number): NDArray;
+/** Element-wise logical NOT */
+export declare function logical_not(x: NDArrayCore): NDArray;
+/** Element-wise logical XOR */
+export declare function logical_xor(x1: NDArrayCore, x2: NDArrayCore | number): NDArray;
+/** Test for finite values */
+export declare function isfinite(x: NDArrayCore): NDArray;
+/** Test for infinity */
+export declare function isinf(x: NDArrayCore): NDArray;
+/** Test for NaN */
+export declare function isnan(x: NDArrayCore): NDArray;
+/** Test for NaT (not a time) - returns all False for numeric arrays */
+export declare function isnat(x: NDArrayCore): NDArray;
+/** Test for negative infinity */
+export declare function isneginf(x: NDArrayCore): NDArray;
+/** Test for positive infinity */
+export declare function isposinf(x: NDArrayCore): NDArray;
+/** Element-wise test for complex values */
+export declare function iscomplex(x: NDArrayCore): NDArray;
+/** Element-wise test for real values */
+export declare function isreal(x: NDArrayCore): NDArray;
+/** Return real array if imaginary part is negligible */
+export declare function real_if_close(x: NDArrayCore, tol?: number): NDArray;
+/** Return sign of x1 with magnitude of x2 */
+export declare function copysign(x1: NDArrayCore, x2: NDArrayCore | number): NDArray;
+/** Test for negative sign bit */
+export declare function signbit(x: NDArrayCore): NDArray;
+/** Next floating-point value toward x2 */
+export declare function nextafter(x1: NDArrayCore, x2: NDArrayCore | number): NDArray;
+/** Spacing between x and nearest adjacent number */
+export declare function spacing(x: NDArrayCore): NDArray;
+/** Element-wise greater than comparison */
+export declare function greater(x1: NDArrayCore, x2: NDArrayCore | number): NDArray;
+/** Element-wise greater than or equal comparison */
+export declare function greater_equal(x1: NDArrayCore, x2: NDArrayCore | number): NDArray;
+/** Element-wise less than comparison */
+export declare function less(x1: NDArrayCore, x2: NDArrayCore | number): NDArray;
+/** Element-wise less than or equal comparison */
+export declare function less_equal(x1: NDArrayCore, x2: NDArrayCore | number): NDArray;
+/** Element-wise equality comparison */
+export declare function equal(x1: NDArrayCore, x2: NDArrayCore | number): NDArray;
+/** Element-wise inequality comparison */
+export declare function not_equal(x1: NDArrayCore, x2: NDArrayCore | number): NDArray;
+/** Element-wise close comparison with tolerance */
+export declare function isclose(a: NDArrayCore, b: NDArrayCore | number, rtol?: number, atol?: number): NDArray;
+/**
+ * Find the coefficients of a polynomial with given roots
+ */
+export declare function poly(seq_of_zeros: NDArrayCore | number[]): NDArray;
+/**
+ * Add two polynomials
+ */
+export declare function polyadd(a1: NDArrayCore | number[], a2: NDArrayCore | number[]): NDArray;
+/**
+ * Differentiate a polynomial
+ */
+export declare function polyder(p: NDArrayCore | number[], m?: number): NDArray;
+/**
+ * Divide two polynomials
+ */
+export declare function polydiv(u: NDArrayCore | number[], v: NDArrayCore | number[]): [NDArray, NDArray];
+/**
+ * Least squares polynomial fit
+ */
+export declare function polyfit(x: NDArrayCore, y: NDArrayCore, deg: number): NDArray;
+/**
+ * Integrate a polynomial
+ */
+export declare function polyint(p: NDArrayCore | number[], m?: number, k?: number | number[]): NDArray;
+/**
+ * Multiply two polynomials
+ */
+export declare function polymul(a1: NDArrayCore | number[], a2: NDArrayCore | number[]): NDArray;
+/**
+ * Subtract two polynomials
+ */
+export declare function polysub(a1: NDArrayCore | number[], a2: NDArrayCore | number[]): NDArray;
+/**
+ * Evaluate a polynomial at given points
+ */
+export declare function polyval(p: NDArrayCore | number[], x: NDArrayCore | number | number[]): NDArray | number;
+/**
+ * Find the roots of a polynomial.
+ *
+ * Uses the companion matrix eigenvalue method (same as NumPy).
+ * Always returns a complex128 NDArrayCore.
+ */
+export declare function roots(p: NDArrayCore | number[]): NDArray;
+/** Sum of array elements */
+export declare function sum(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArray | number | bigint | Complex;
+/** Mean of array elements */
+export declare function mean(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArray | number | Complex;
+/** Product of array elements */
+export declare function prod(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArray | number | bigint | Complex;
+/** Maximum of array elements */
+export declare function max(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArray | number | Complex;
+/** Minimum of array elements */
+export declare function min(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArray | number | Complex;
+/** Peak-to-peak (max - min) */
+export declare function ptp(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArray | number | Complex;
+/** Index of minimum value */
+export declare function argmin(a: NDArrayCore, axis?: number): NDArray | number;
+/** Index of maximum value */
+export declare function argmax(a: NDArrayCore, axis?: number): NDArray | number;
+/** Variance of array elements */
+export declare function variance(a: NDArrayCore, axis?: number, ddof?: number, keepdims?: boolean): NDArray | number;
+/** Standard deviation of array elements */
+export declare function std(a: NDArrayCore, axis?: number, ddof?: number, keepdims?: boolean): NDArray | number;
+/** Median of array elements */
+export declare function median(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArray | number;
+/** Percentile of array elements */
+export declare function percentile(a: NDArrayCore, q: number, axis?: number, keepdims?: boolean): NDArray | number;
+/** Quantile of array elements */
+export declare function quantile(a: NDArrayCore, q: number, axis?: number, keepdims?: boolean): NDArray | number;
+/** Weighted average */
+export declare function average(a: NDArrayCore, axis?: number, weights?: NDArrayCore, keepdims?: boolean): NDArray | number | Complex;
+/** Test if all elements are true */
+export declare function all(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArray | boolean;
+/** Test if any element is true */
+export declare function any(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArray | boolean;
+/** Cumulative sum */
+export declare function cumsum(a: NDArrayCore, axis?: number): NDArray;
+/** Cumulative product */
+export declare function cumprod(a: NDArrayCore, axis?: number): NDArray;
+/** Sum ignoring NaN */
+export declare function nansum(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArray | number | Complex;
+/** Product ignoring NaN */
+export declare function nanprod(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArray | number | Complex;
+/** Mean ignoring NaN */
+export declare function nanmean(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArray | number | Complex;
+/** Variance ignoring NaN */
+export declare function nanvar(a: NDArrayCore, axis?: number, ddof?: number, keepdims?: boolean): NDArray | number;
+/** Standard deviation ignoring NaN */
+export declare function nanstd(a: NDArrayCore, axis?: number, ddof?: number, keepdims?: boolean): NDArray | number;
+/** Minimum ignoring NaN */
+export declare function nanmin(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArray | number | Complex;
+/** Maximum ignoring NaN */
+export declare function nanmax(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArray | number | Complex;
+/** Index of minimum ignoring NaN */
+export declare function nanargmin(a: NDArrayCore, axis?: number): NDArray | number;
+/** Index of maximum ignoring NaN */
+export declare function nanargmax(a: NDArrayCore, axis?: number): NDArray | number;
+/** Cumulative sum ignoring NaN */
+export declare function nancumsum(a: NDArrayCore, axis?: number): NDArray;
+/** Cumulative product ignoring NaN */
+export declare function nancumprod(a: NDArrayCore, axis?: number): NDArray;
+/** Median ignoring NaN */
+export declare function nanmedian(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArray | number;
+/** Quantile ignoring NaN */
+export declare function nanquantile(a: NDArrayCore, q: number, axis?: number, keepdims?: boolean): NDArray | number;
+/** Percentile ignoring NaN */
+export declare function nanpercentile(a: NDArrayCore, q: number, axis?: number, keepdims?: boolean): NDArray | number;
+/** Round to given decimals */
+export declare function around(a: NDArrayCore, decimals?: number): NDArray;
+/** Round (same as around) */
+export declare function round(a: NDArrayCore, decimals?: number): NDArray;
+/** Ceiling */
+export declare function ceil(x: NDArrayCore): NDArray;
+/** Round toward zero */
+export declare function fix(x: NDArrayCore): NDArray;
+/** Floor */
+export declare function floor(x: NDArrayCore): NDArray;
+/** Round to nearest integer */
+export declare function rint(x: NDArrayCore): NDArray;
+/** Truncate toward zero */
+export declare function trunc(x: NDArrayCore): NDArray;
+/** Test if elements in ar1 are in ar2 (deprecated, use isin) */
+export declare function in1d(ar1: NDArrayCore, ar2: NDArrayCore): NDArray;
+/** Find intersection of two arrays */
+export declare function intersect1d(ar1: NDArrayCore, ar2: NDArrayCore): NDArray;
+/** Test if elements are in test elements */
+export declare function isin(element: NDArrayCore, testElements: NDArrayCore): NDArray;
+/** Find set difference (elements in ar1 not in ar2) */
+export declare function setdiff1d(ar1: NDArrayCore, ar2: NDArrayCore): NDArray;
+/** Find symmetric difference (elements in either but not both) */
+export declare function setxor1d(ar1: NDArrayCore, ar2: NDArrayCore): NDArray;
+/** Find union of two arrays */
+export declare function union1d(ar1: NDArrayCore, ar2: NDArrayCore): NDArray;
+/** Trim leading/trailing zeros */
+export declare function trim_zeros(filt: NDArrayCore, trim?: 'f' | 'b' | 'fb'): NDArray;
+/** Return unique values (Array API) */
+export declare function unique_values(x: NDArrayCore): NDArray;
+/**
+ * Append values to the end of an array
+ */
+export declare function append(arr: NDArrayCore, values: NDArrayCore | number | number[], axis?: number): NDArray;
+/**
+ * Delete elements from an array
+ */
+export declare function delete_(arr: NDArrayCore, obj: number | number[], axis?: number): NDArray;
+/**
+ * Insert values along an axis
+ */
+export declare function insert(arr: NDArrayCore, obj: number | number[], values: NDArrayCore | number | number[], axis?: number): NDArray;
+/**
+ * Pad an array
+ */
+export declare function pad(arr: NDArrayCore, pad_width: number | [number, number] | [number, number][], mode?: 'constant' | 'edge' | 'linear_ramp' | 'maximum' | 'mean' | 'median' | 'minimum' | 'reflect' | 'symmetric' | 'wrap' | 'empty', constant_values?: number): NDArray;
+/** Reshape array without changing data */
+export declare function reshape(a: NDArrayCore, newShape: number[]): NDArray;
+/** Flatten array to 1D */
+export declare function flatten(a: NDArrayCore): NDArray;
+/** Return contiguous flattened array */
+export declare function ravel(a: NDArrayCore): NDArray;
+/** Remove single-dimensional entries from shape - returns a view */
+export declare function squeeze(a: NDArrayCore, axis?: number): NDArray;
+/** Expand array dimensions - returns a view */
+export declare function expand_dims(a: NDArrayCore, axis: number): NDArray;
+/** Interchange two axes - returns a view */
+export declare function swapaxes(a: NDArrayCore, axis1: number, axis2: number): NDArray;
+/** Move axis to new position - returns a view */
+export declare function moveaxis(a: NDArrayCore, source: number | number[], destination: number | number[]): NDArray;
+/** Roll axis to given position - returns a view */
+export declare function rollaxis(a: NDArrayCore, axis: number, start?: number): NDArray;
+/** Join arrays along an existing axis */
+export declare function concatenate(arrays: NDArrayCore[], axis?: number): NDArray;
+/** Join arrays along a new axis */
+export declare function stack(arrays: NDArrayCore[], axis?: number): NDArray;
+/** Stack arrays vertically (row-wise) */
+export declare function vstack(arrays: NDArrayCore[]): NDArray;
+/** Stack arrays horizontally (column-wise) */
+export declare function hstack(arrays: NDArrayCore[]): NDArray;
+/** Stack arrays along third axis (depth-wise) */
+export declare function dstack(arrays: NDArrayCore[]): NDArray;
+/** Concatenate (alias) */
+export declare function concat(arrays: NDArrayCore[], axis?: number): NDArray;
+/** Stack 1D arrays as columns */
+export declare function column_stack(arrays: NDArrayCore[]): NDArray;
+/** Assemble arrays from nested sequences of blocks */
+export declare function block(arrays: NDArrayCore[]): NDArray;
+/** Unstack array into list of arrays */
+export declare function unstack(a: NDArrayCore, axis?: number): NDArray[];
+/** Tile array by given repetitions */
+export declare function tile(a: NDArrayCore, reps: number | number[]): NDArray;
+/** Repeat elements of array */
+export declare function repeat(a: NDArrayCore, repeats: number | number[], axis?: number): NDArray;
+/** Reverse order of elements along axis */
+export declare function flip(m: NDArrayCore, axis?: number | number[]): NDArray;
+/** Flip array left/right */
+export declare function fliplr(m: NDArrayCore): NDArray;
+/** Flip array up/down */
+export declare function flipud(m: NDArrayCore): NDArray;
+/** Rotate array by 90 degrees */
+export declare function rot90(m: NDArrayCore, k?: number, axes?: [number, number]): NDArray;
+/** Roll array elements along axis */
+export declare function roll(a: NDArrayCore, shift: number | number[], axis?: number | number[]): NDArray;
+/** Resize array to new shape */
+export declare function resize(a: NDArrayCore, new_shape: number[]): NDArray;
+/** Sort array along axis */
+export declare function sort(a: NDArrayCore, axis?: number): NDArray;
+/** Indices that would sort array */
+export declare function argsort(a: NDArrayCore, axis?: number): NDArray;
+/** Indirect stable sort on multiple keys */
+export declare function lexsort(keys: NDArrayCore[]): NDArray;
+/** Partially sort array */
+export declare function partition(a: NDArrayCore, kth: number, axis?: number): NDArray;
+/** Indices that would partially sort array */
+export declare function argpartition(a: NDArrayCore, kth: number, axis?: number): NDArray;
+/** Sort complex array */
+export declare function sort_complex(a: NDArrayCore): NDArray;
+/** Indices of non-zero elements */
+export declare function nonzero(a: NDArrayCore): NDArray[];
+/** Indices where condition is True */
+export declare function argwhere(a: NDArrayCore): NDArray;
+/** Indices of non-zero elements in flattened array */
+export declare function flatnonzero(a: NDArrayCore): NDArray;
+/** Extract elements where condition is True */
+export declare function extract(condition: NDArrayCore, a: NDArrayCore): NDArray;
+/** Count occurrences of values */
+export declare function bincount(x: NDArrayCore, weights?: NDArrayCore, minlength?: number): NDArray;
+/** Digitize values into bins */
+export declare function digitize(x: NDArrayCore, bins: NDArrayCore, right?: boolean): NDArray;
+/** Cross-correlation */
+export declare function correlate(a: NDArrayCore, v: NDArrayCore, mode?: 'valid' | 'same' | 'full'): NDArray;
+/** Convolution */
+export declare function convolve(a: NDArrayCore, v: NDArrayCore, mode?: 'valid' | 'same' | 'full'): NDArray;
+/** Covariance matrix */
+export declare function cov(m: NDArrayCore, y?: NDArrayCore, rowvar?: boolean, bias?: boolean, ddof?: number): NDArray;
+/** Correlation coefficients */
+export declare function corrcoef(x: NDArrayCore, y?: NDArrayCore, rowvar?: boolean): NDArray;
+/** Integrate using trapezoidal rule */
+export declare function trapezoid(y: NDArrayCore, x?: NDArrayCore, dx?: number, axis?: number): NDArray | number;
+/** Sine of array elements */
+export declare function sin(x: NDArrayCore): NDArray;
+/** Cosine of array elements */
+export declare function cos(x: NDArrayCore): NDArray;
+/** Tangent of array elements */
+export declare function tan(x: NDArrayCore): NDArray;
+/** Inverse sine */
+export declare function arcsin(x: NDArrayCore): NDArray;
+/** Inverse cosine */
+export declare function arccos(x: NDArrayCore): NDArray;
+/** Inverse tangent */
+export declare function arctan(x: NDArrayCore): NDArray;
+/** Two-argument inverse tangent */
+export declare function arctan2(x1: NDArrayCore, x2: NDArrayCore | number): NDArray;
+/** Hypotenuse (sqrt(x1^2 + x2^2)) */
+export declare function hypot(x1: NDArrayCore, x2: NDArrayCore | number): NDArray;
+/** Convert radians to degrees */
+export declare function degrees(x: NDArrayCore): NDArray;
+/** Convert degrees to radians */
+export declare function radians(x: NDArrayCore): NDArray;
+/** Convert degrees to radians (alias) */
+export declare function deg2rad(x: NDArrayCore): NDArray;
+/** Convert radians to degrees (alias) */
+export declare function rad2deg(x: NDArrayCore): NDArray;
+/** Hyperbolic sine */
+export declare function sinh(x: NDArrayCore): NDArray;
+/** Hyperbolic cosine */
+export declare function cosh(x: NDArrayCore): NDArray;
+/** Hyperbolic tangent */
+export declare function tanh(x: NDArrayCore): NDArray;
+/** Inverse hyperbolic sine */
+export declare function arcsinh(x: NDArrayCore): NDArray;
+/** Inverse hyperbolic cosine */
+export declare function arccosh(x: NDArrayCore): NDArray;
+/** Inverse hyperbolic tangent */
+export declare function arctanh(x: NDArrayCore): NDArray;
+export { broadcast_arrays, broadcast_shapes, put, put_along_axis, place, putmask, copyto, ix_, fill_diagonal, array_equal, array_equiv, may_share_memory, shares_memory, geterr, seterr, pow, abs, true_divide, conjugate, array2string, array_repr, array_str, set_printoptions, get_printoptions, printoptions, format_float_positional, format_float_scientific, base_repr, binary_repr, gradient, trace, einsum, einsum_path, vdot, linalg, iscomplexobj, isrealobj, isfortran, isscalar, iterable, isdtype, promote_types, allclose, amax, amin, var_, cumulative_sum, cumulative_prod, round_, unique, unique_all, unique_counts, unique_inverse, split, array_split, vsplit, hsplit, dsplit, atleast_1d, atleast_2d, atleast_3d, row_stack, where, searchsorted, count_nonzero, histogram, histogram2d, histogramdd, histogram_bin_edges, asin, acos, atan, atan2, asinh, acosh, atanh, can_cast, common_type, result_type, min_scalar_type, issubdtype, typename, mintypecode, ndim, shape, size, item, tolist, tobytes, byteswap, view, tofile, fill, } from '../core';
+//# sourceMappingURL=index.d.ts.map