numpy-ts 0.10.0 → 0.12.0

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

@@ -4,6 +4,7 @@
  * 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;
@@ -61,19 +62,22 @@ export declare class NDArray {
      * 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>;
+    [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, number otherwise)
+     * @returns The element value (BigInt for int64/uint64, Complex for complex, number otherwise)
      */
-    get(indices: number[]): number | bigint;
+    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): void;
+    set(indices: number[], value: number | bigint | Complex | {
+        re: number;
+        im: number;
+    }): void;
     /**
      * Return a deep copy of the array
      */
@@ -515,7 +519,7 @@ export declare class NDArray {
      * @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;
+    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
@@ -524,28 +528,28 @@ export declare class NDArray {
      *
      * Note: mean() returns float64 for integer dtypes, matching NumPy behavior
      */
-    mean(axis?: number, keepdims?: boolean): NDArray | number;
+    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;
+    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;
+    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;
+    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.
@@ -606,7 +610,7 @@ export declare class NDArray {
      * @param keepdims - If true, reduced axes are left as dimensions with size 1
      * @returns Range of values
      */
-    ptp(axis?: number, keepdims?: boolean): NDArray | number;
+    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.
@@ -636,28 +640,28 @@ export declare class NDArray {
      * @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;
+    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;
+    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;
+    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;
+    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.
@@ -680,14 +684,30 @@ export declare class NDArray {
      * @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;
+    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;
+    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.
@@ -839,6 +859,56 @@ export declare class NDArray {
      * @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
@@ -848,20 +918,20 @@ export declare class NDArray {
     /**
      * Dot product (matching NumPy behavior)
      * @param other - Array to dot with
-     * @returns Result of dot product (scalar or array depending on dimensions)
+     * @returns Result of dot product (scalar or array depending on dimensions, Complex for complex arrays)
      */
-    dot(other: NDArray): NDArray | number | bigint;
+    dot(other: NDArray): NDArray | number | bigint | Complex;
     /**
      * Sum of diagonal elements (trace)
-     * @returns Sum of diagonal elements
+     * @returns Sum of diagonal elements (Complex for complex arrays)
      */
-    trace(): number | bigint;
+    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
+     * @returns Inner product result (Complex for complex arrays)
      */
-    inner(other: NDArray): NDArray | number | bigint;
+    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
@@ -874,7 +944,7 @@ export declare class NDArray {
      * @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;
+    tensordot(other: NDArray, axes?: number | [number[], number[]]): NDArray | number | bigint | Complex;
     /**
      * Element-wise cube root
      * Promotes integer types to float64
@@ -952,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
@@ -1053,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
@@ -1355,16 +1465,16 @@ export declare function reciprocal(x: NDArray): NDArray;
  *
  * @param a - First array
  * @param b - Second array
- * @returns Result of dot product
+ * @returns Result of dot product (Complex for complex arrays)
  */
-export declare function dot(a: NDArray, b: NDArray): NDArray | number | bigint;
+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
+ * @returns Sum of diagonal elements (Complex for complex arrays)
  */
-export declare function trace(a: NDArray): number | bigint;
+export declare function trace(a: NDArray): number | bigint | Complex;
 /**
  * Extract a diagonal from a matrix or N-D array
  *
@@ -1399,9 +1509,9 @@ export declare function transpose(a: NDArray, axes?: number[]): NDArray;
  *
  * @param a - First array
  * @param b - Second array
- * @returns Inner product result
+ * @returns Inner product result (Complex for complex arrays)
  */
-export declare function inner(a: NDArray, b: NDArray): NDArray | number | bigint;
+export declare function inner(a: NDArray, b: NDArray): NDArray | number | bigint | Complex;
 /**
  * Outer product of two arrays
  *
@@ -1420,7 +1530,7 @@ export declare function outer(a: NDArray, b: NDArray): NDArray;
  * @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;
+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)
@@ -1594,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
  *
@@ -1652,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
  *
@@ -1857,6 +2011,44 @@ export declare function take(a: NDArray, indices: number[], axis?: number): NDAr
  * @param values - Values to put
  */
 export declare function put(a: NDArray, indices: number[], values: NDArray | number | bigint): void;
+/**
+ * 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.
  *
@@ -1922,7 +2114,7 @@ export { cumprod as cumulative_prod };
  * @param keepdims - If true, reduced axes are left as dimensions with size 1
  * @returns Maximum value(s)
  */
-export declare function max(a: NDArray, axis?: number, keepdims?: boolean): NDArray | number;
+export declare function max(a: NDArray, axis?: number, keepdims?: boolean): NDArray | number | Complex;
 export { max as amax };
 /**
  * Return the minimum along a given axis.
@@ -1931,7 +2123,7 @@ export { max as amax };
  * @param keepdims - If true, reduced axes are left as dimensions with size 1
  * @returns Minimum value(s)
  */
-export declare function min(a: NDArray, axis?: number, keepdims?: boolean): NDArray | number;
+export 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.
@@ -1940,7 +2132,7 @@ export { min as amin };
  * @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;
+export declare function ptp(a: NDArray, axis?: number, keepdims?: boolean): NDArray | number | Complex;
 /**
  * Compute the median along the specified axis.
  * @param a - Input array
@@ -1975,7 +2167,7 @@ export declare function quantile(a: NDArray, q: number, axis?: number, keepdims?
  * @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;
+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
@@ -1983,7 +2175,7 @@ export declare function average(a: NDArray, axis?: number, weights?: NDArray, ke
  * @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;
+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
@@ -1991,7 +2183,7 @@ export declare function nansum(a: NDArray, axis?: number, keepdims?: boolean): N
  * @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;
+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
@@ -1999,7 +2191,7 @@ export declare function nanprod(a: NDArray, axis?: number, keepdims?: boolean):
  * @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;
+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
@@ -2025,7 +2217,7 @@ export declare function nanstd(a: NDArray, axis?: number, ddof?: number, keepdim
  * @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;
+export declare function nanmin(a: NDArray, axis?: number, keepdims?: boolean): NDArray | number | Complex;
 /**
  * Return maximum of an array, ignoring NaNs.
  * @param a - Input array
@@ -2033,7 +2225,7 @@ export declare function nanmin(a: NDArray, axis?: number, keepdims?: boolean): N
  * @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;
+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
@@ -2070,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
  *
@@ -2164,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
  *
@@ -2242,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
  *
@@ -2346,33 +2686,82 @@ export declare function nextafter(x1: NDArray, x2: NDArray | number): NDArray;
  */
 export declare function spacing(x: NDArray): NDArray;
 /**
- * Test element-wise for complex number
- * Since numpy-ts doesn't support complex numbers, always returns false
+ * 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 (all false)
+ * @returns Boolean array
  */
 export declare function iscomplex(x: NDArray): NDArray;
 /**
- * Check whether array is complex type
- * Since numpy-ts doesn't support complex numbers, always returns false
+ * Check whether array is complex type.
+ *
  * @param x - Input array
- * @returns false
+ * @returns true if dtype is complex64 or complex128
  */
 export declare function iscomplexobj(x: NDArray): boolean;
 /**
- * Test element-wise for real number (not complex)
- * Since numpy-ts doesn't support complex numbers, always returns true
+ * 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 (all true)
+ * @returns Boolean array
  */
 export declare function isreal(x: NDArray): NDArray;
 /**
- * Check whether array is real type (not complex)
- * Since numpy-ts doesn't support complex numbers, always returns true
+ * Check whether array is real type (not complex).
+ *
  * @param x - Input array
- * @returns true
+ * @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
@@ -2446,7 +2835,72 @@ export declare function promote_types(dtype1: DType, dtype2: DType): DType;
  * // Trace
  * einsum('ii->', a)
  */
-export declare function einsum(subscripts: string, ...operands: NDArray[]): NDArray | number | bigint;
+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
  */
@@ -2548,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.
@@ -2896,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
@@ -3022,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