numpy-ts 0.11.0 → 0.12.0

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

@@ -692,6 +692,22 @@ export declare class NDArray {
      * @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.
@@ -1006,6 +1022,30 @@ export declare class NDArray {
      * @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
@@ -1107,6 +1147,22 @@ export declare function identity(n: number, dtype?: DType): NDArray;
  * @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
@@ -1648,6 +1704,18 @@ export declare function hstack(arrays: NDArray[]): NDArray;
  * @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
  *
@@ -1706,6 +1774,38 @@ export declare function repeat(a: NDArray, repeats: number | number[], axis?: nu
  * @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
  *
@@ -2162,6 +2262,14 @@ export declare function nancumprod(a: NDArray, axis?: number): NDArray;
  * @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
  *
@@ -2256,6 +2364,116 @@ export declare function ldexp(x1: NDArray, x2: NDArray | number): NDArray;
  * @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
  *
@@ -2334,6 +2552,36 @@ export declare function packbits(a: NDArray, axis?: number, bitorder?: 'big' | '
  * @returns Unpacked uint8 array of 0s and 1s
  */
 export declare function unpackbits(a: NDArray, axis?: number, count?: number, bitorder?: 'big' | 'little'): NDArray;
+/**
+ * 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
  *
@@ -2588,6 +2836,71 @@ export declare function promote_types(dtype1: DType, dtype2: DType): DType;
  * 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
  */
@@ -2689,6 +3002,57 @@ export declare const linalg: {
      * 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.
@@ -3037,6 +3401,55 @@ export declare function setxor1d(ar1: NDArray, ar2: NDArray): NDArray;
  * @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
@@ -3163,4 +3576,348 @@ export declare function cov(m: NDArray, y?: NDArray, rowvar?: boolean, bias?: bo
  * @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