numpy-ts 0.10.0 → 0.12.0

package/dist/types/ops/linalg.d.ts

@@ -5,6 +5,7 @@
  * @module ops/linalg
  */
 import { ArrayStorage } from '../core/storage';
+import { Complex } from '../core/complex';
 /**
  * Dot product of two arrays (fully NumPy-compatible)
  *
@@ -21,7 +22,7 @@ import { ArrayStorage } from '../core/storage';
  *
  * For 2D·2D, prefer using matmul() instead.
  */
-export declare function dot(a: ArrayStorage, b: ArrayStorage): ArrayStorage | number | bigint;
+export declare function dot(a: ArrayStorage, b: ArrayStorage): ArrayStorage | number | bigint | Complex;
 /**
  * Matrix multiplication
  * Requires 2D arrays with compatible shapes
@@ -42,7 +43,7 @@ export declare function matmul(a: ArrayStorage, b: ArrayStorage): ArrayStorage;
  * @param a - Input 2D array
  * @returns Sum of diagonal elements
  */
-export declare function trace(a: ArrayStorage): number | bigint;
+export declare function trace(a: ArrayStorage): number | bigint | Complex;
 /**
  * Permute the dimensions of an array
  *
@@ -67,7 +68,7 @@ export declare function transpose(a: ArrayStorage, axes?: number[]): ArrayStorag
  * @param b - Second array
  * @returns Inner product result
  */
-export declare function inner(a: ArrayStorage, b: ArrayStorage): ArrayStorage | number | bigint;
+export declare function inner(a: ArrayStorage, b: ArrayStorage): ArrayStorage | number | bigint | Complex;
 /**
  * Outer product of two vectors
  *
@@ -91,7 +92,7 @@ export declare function outer(a: ArrayStorage, b: ArrayStorage): ArrayStorage;
  *   - [a_axes, b_axes]: Contract specified axes
  * @returns Tensor dot product
  */
-export declare function tensordot(a: ArrayStorage, b: ArrayStorage, axes: number | [number[], number[]]): ArrayStorage | number | bigint;
+export declare function tensordot(a: ArrayStorage, b: ArrayStorage, axes: number | [number[], number[]]): ArrayStorage | number | bigint | Complex;
 /**
  * Extract a diagonal or construct a diagonal array.
  *
@@ -126,7 +127,7 @@ export declare function diagonal(a: ArrayStorage, offset?: number, axis1?: numbe
  * @param operands - Input arrays
  * @returns Result of the Einstein summation
  */
-export declare function einsum(subscripts: string, ...operands: ArrayStorage[]): ArrayStorage | number | bigint;
+export declare function einsum(subscripts: string, ...operands: ArrayStorage[]): ArrayStorage | number | bigint | Complex;
 /**
  * Kronecker product of two arrays.
  *
@@ -363,4 +364,128 @@ export declare function eigvals(a: ArrayStorage): ArrayStorage;
  * @returns Array of eigenvalues (sorted ascending)
  */
 export declare function eigvalsh(a: ArrayStorage, UPLO?: 'L' | 'U'): ArrayStorage;
+/**
+ * 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: ArrayStorage, b: ArrayStorage): 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: ArrayStorage, b: ArrayStorage, axis?: number): ArrayStorage | 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: ArrayStorage): ArrayStorage;
+/**
+ * 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: ArrayStorage, axes?: number[]): ArrayStorage;
+/**
+ * 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: ArrayStorage, x2: ArrayStorage): ArrayStorage;
+/**
+ * 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: ArrayStorage, x2: ArrayStorage): ArrayStorage;
+/**
+ * Compute sign and (natural) logarithm of the determinant.
+ *
+ * Returns (sign, logabsdet) where sign is the sign of the determinant
+ * and logabsdet is the natural log of the absolute value of the determinant.
+ *
+ * This is useful for computing determinants of large matrices where the
+ * determinant itself might overflow or underflow.
+ *
+ * @param a - Square matrix
+ * @returns { sign, logabsdet }
+ */
+export declare function slogdet(a: ArrayStorage): {
+    sign: number;
+    logabsdet: number;
+};
+/**
+ * Compute singular values of a matrix.
+ *
+ * This is equivalent to svd(a, compute_uv=False) but more efficient
+ * as it doesn't compute the U and V matrices.
+ *
+ * @param a - Input matrix (m x n)
+ * @returns 1D array of singular values in descending order
+ */
+export declare function svdvals(a: ArrayStorage): ArrayStorage;
+/**
+ * Compute the dot product of two or more arrays in a single function call.
+ *
+ * Optimizes the order of multiplications to minimize computation.
+ * For example, for three arrays A, B, C with shapes (10, 100), (100, 5), (5, 50),
+ * it's more efficient to compute (A @ B) @ C than A @ (B @ C).
+ *
+ * @param arrays - List of arrays to multiply
+ * @returns Result of multiplying all arrays
+ */
+export declare function multi_dot(arrays: ArrayStorage[]): ArrayStorage;
+/**
+ * Compute the 'inverse' of an N-dimensional array.
+ *
+ * The inverse is defined such that tensordot(tensorinv(a), a, ind) == I
+ * where I is the identity operator.
+ *
+ * @param a - Input array to invert
+ * @param ind - Number of first indices that are involved in the inverse sum (default: 2)
+ * @returns Tensor inverse
+ */
+export declare function tensorinv(a: ArrayStorage, ind?: number): ArrayStorage;
+/**
+ * Solve the tensor equation a x = b for x.
+ *
+ * This is equivalent to solve after reshaping a and b appropriately.
+ *
+ * @param a - Coefficient tensor
+ * @param b - Target tensor
+ * @param axes - Axes of a to be summed over in the contraction (default based on b.ndim)
+ * @returns Solution tensor x
+ */
+export declare function tensorsolve(a: ArrayStorage, b: ArrayStorage, axes?: number[] | null): ArrayStorage;
 //# sourceMappingURL=linalg.d.ts.map

package/dist/types/ops/logic.d.ts

@@ -56,6 +56,8 @@ export declare function logical_xor(a: ArrayStorage, b: ArrayStorage | number):
 /**
  * Test element-wise for finiteness (not infinity and not NaN)
  *
+ * For complex numbers: True if both real and imaginary parts are finite.
+ *
  * @param a - Input array storage
  * @returns Boolean result storage
  */
@@ -63,6 +65,8 @@ export declare function isfinite(a: ArrayStorage): ArrayStorage;
 /**
  * Test element-wise for positive or negative infinity
  *
+ * For complex numbers: True if either real or imaginary part is infinite.
+ *
  * @param a - Input array storage
  * @returns Boolean result storage
  */
@@ -70,6 +74,8 @@ export declare function isinf(a: ArrayStorage): ArrayStorage;
 /**
  * Test element-wise for NaN (Not a Number)
  *
+ * For complex numbers: True if either real or imaginary part is NaN.
+ *
  * @param a - Input array storage
  * @returns Boolean result storage
  */
@@ -119,41 +125,53 @@ export declare function nextafter(x1: ArrayStorage, x2: ArrayStorage | number):
  */
 export declare function spacing(a: ArrayStorage): ArrayStorage;
 /**
- * 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 a - Input array storage
- * @returns Boolean array (all false)
+ * @returns Boolean array
  */
 export declare function iscomplex(a: ArrayStorage): ArrayStorage;
 /**
- * Check whether object is complex type array
- * Since numpy-ts doesn't support complex numbers, always returns false
- * @param _a - Input array storage (unused)
- * @returns false
+ * Check whether object is complex type array.
+ *
+ * @param a - Input array storage
+ * @returns true if dtype is complex64 or complex128
  */
-export declare function iscomplexobj(_a: ArrayStorage): boolean;
+export declare function iscomplexobj(a: ArrayStorage): 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 a - Input array storage
- * @returns Boolean array (all true)
+ * @returns Boolean array
  */
 export declare function isreal(a: ArrayStorage): ArrayStorage;
 /**
- * Check whether object is real type array (not complex)
- * Since numpy-ts doesn't support complex numbers, always returns true
- * @param _a - Input array storage (unused)
- * @returns true
+ * Check whether object is real type array (not complex).
+ *
+ * @param a - Input array storage
+ * @returns true if dtype is NOT complex64 or complex128
  */
-export declare function isrealobj(_a: ArrayStorage): boolean;
+export declare function isrealobj(a: ArrayStorage): boolean;
 /**
  * Test element-wise for negative infinity
+ *
+ * For complex numbers: True if either real or imaginary part is -Infinity.
+ *
  * @param a - Input array storage
  * @returns Boolean array
  */
 export declare function isneginf(a: ArrayStorage): ArrayStorage;
 /**
  * Test element-wise for positive infinity
+ *
+ * For complex numbers: True if either real or imaginary part is +Infinity.
+ *
  * @param a - Input array storage
  * @returns Boolean array
  */
@@ -171,7 +189,7 @@ export declare function isfortran(a: ArrayStorage): boolean;
  * @param _tol - Tolerance (unused, for API compatibility)
  * @returns Copy of input array
  */
-export declare function real_if_close(a: ArrayStorage, _tol?: number): ArrayStorage;
+export declare function real_if_close(a: ArrayStorage, tol?: number): ArrayStorage;
 /**
  * Check if element is a scalar type
  * @param val - Value to check

package/dist/types/ops/reduction.d.ts

@@ -5,30 +5,29 @@
  * @module ops/reduction
  */
 import { ArrayStorage } from '../core/storage';
+import { Complex } from '../core/complex';
 /**
  * Sum array elements over a given axis
  */
-export declare function sum(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
+export declare function sum(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number | Complex;
 /**
  * Compute the arithmetic mean along the specified axis
  * Note: mean() returns float64 for integer dtypes, matching NumPy behavior
+ * For complex arrays, returns complex mean
  */
-export declare function mean(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
+export declare function mean(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number | Complex;
 /**
  * Return the maximum along a given axis
  */
-export declare function max(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
+export declare function max(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number | Complex;
 /**
  * Product array elements over a given axis
  */
-export declare function prod(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
+export declare function prod(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number | Complex;
 /**
  * Return the minimum along a given axis
  */
-export declare function min(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
-/**
- * Return the indices of the minimum values along a given axis
- */
+export declare function min(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number | Complex;
 export declare function argmin(storage: ArrayStorage, axis?: number): ArrayStorage | number;
 /**
  * Return the indices of the maximum values along a given axis
@@ -40,6 +39,9 @@ export declare function argmax(storage: ArrayStorage, axis?: number): ArrayStora
  * @param axis - Axis along which to compute variance
  * @param ddof - Delta degrees of freedom (default: 0)
  * @param keepdims - Keep dimensions (default: false)
+ *
+ * For complex arrays: Var(X) = E[|X - E[X]|²] where |z|² = re² + im²
+ * Returns real values (float64) for both real and complex input
  */
 export declare function variance(storage: ArrayStorage, axis?: number, ddof?: number, keepdims?: boolean): ArrayStorage | number;
 /**
@@ -48,6 +50,9 @@ export declare function variance(storage: ArrayStorage, axis?: number, ddof?: nu
  * @param axis - Axis along which to compute std
  * @param ddof - Delta degrees of freedom (default: 0)
  * @param keepdims - Keep dimensions (default: false)
+ *
+ * For complex arrays: returns sqrt(Var(X)) where Var(X) = E[|X - E[X]|²]
+ * Returns real values (float64) for both real and complex input
  */
 export declare function std(storage: ArrayStorage, axis?: number, ddof?: number, keepdims?: boolean): ArrayStorage | number;
 /**
@@ -60,16 +65,19 @@ export declare function all(storage: ArrayStorage, axis?: number, keepdims?: boo
 export declare function any(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | boolean;
 /**
  * Return cumulative sum of elements along a given axis
+ * For complex arrays: returns complex cumulative sum
  */
 export declare function cumsum(storage: ArrayStorage, axis?: number): ArrayStorage;
 /**
  * Return cumulative product of elements along a given axis
+ * For complex arrays: returns complex cumulative product
+ * Complex multiplication: (a+bi)(c+di) = (ac-bd) + (ad+bc)i
  */
 export declare function cumprod(storage: ArrayStorage, axis?: number): ArrayStorage;
 /**
  * Peak to peak (maximum - minimum) value along a given axis
  */
-export declare function ptp(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
+export declare function ptp(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number | Complex;
 /**
  * Compute the median along the specified axis
  */
@@ -85,41 +93,40 @@ export declare function quantile(storage: ArrayStorage, q: number, axis?: number
 /**
  * Compute the weighted average along the specified axis
  */
-export declare function average(storage: ArrayStorage, axis?: number, weights?: ArrayStorage, keepdims?: boolean): ArrayStorage | number;
-/**
- * Return sum of elements, treating NaNs as zero
- */
-export declare function nansum(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
+export declare function average(storage: ArrayStorage, axis?: number, weights?: ArrayStorage, keepdims?: boolean): ArrayStorage | number | Complex;
+export declare function nansum(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number | Complex;
 /**
  * Return product of elements, treating NaNs as one
  */
-export declare function nanprod(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
+export declare function nanprod(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number | Complex;
 /**
  * Compute mean ignoring NaN values
  */
-export declare function nanmean(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
+export declare function nanmean(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number | Complex;
 /**
  * Compute variance ignoring NaN values
  */
 export declare function nanvar(storage: ArrayStorage, axis?: number, ddof?: number, keepdims?: boolean): ArrayStorage | number;
 /**
  * Compute standard deviation ignoring NaN values
+ * For complex arrays: returns sqrt of variance (always real values)
  */
 export declare function nanstd(storage: ArrayStorage, axis?: number, ddof?: number, keepdims?: boolean): ArrayStorage | number;
 /**
  * Return minimum ignoring NaN values
  */
-export declare function nanmin(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
+export declare function nanmin(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number | Complex;
 /**
  * Return maximum ignoring NaN values
  */
-export declare function nanmax(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
+export declare function nanmax(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number | Complex;
 /**
  * Return indices of minimum value, ignoring NaNs
  */
 export declare function nanargmin(storage: ArrayStorage, axis?: number): ArrayStorage | number;
 /**
  * Return indices of maximum value, ignoring NaNs
+ * For complex arrays: uses lexicographic ordering (real first, then imaginary)
  */
 export declare function nanargmax(storage: ArrayStorage, axis?: number): ArrayStorage | number;
 /**
@@ -128,10 +135,19 @@ export declare function nanargmax(storage: ArrayStorage, axis?: number): ArraySt
 export declare function nancumsum(storage: ArrayStorage, axis?: number): ArrayStorage;
 /**
  * Return cumulative product, treating NaNs as one
+ * For complex arrays: NaN values (either part NaN) are treated as 1+0i
  */
 export declare function nancumprod(storage: ArrayStorage, axis?: number): ArrayStorage;
 /**
  * Compute median ignoring NaN values
  */
 export declare function nanmedian(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
+/**
+ * Compute the q-th quantile of data along specified axis, ignoring NaNs
+ */
+export declare function nanquantile(storage: ArrayStorage, q: number, axis?: number, keepdims?: boolean): ArrayStorage | number;
+/**
+ * Compute the q-th percentile of data along specified axis, ignoring NaNs
+ */
+export declare function nanpercentile(storage: ArrayStorage, q: number, axis?: number, keepdims?: boolean): ArrayStorage | number;
 //# sourceMappingURL=reduction.d.ts.map

package/dist/types/ops/rounding.d.ts

@@ -3,6 +3,9 @@
  *
  * Pure functions for element-wise rounding operations:
  * around, ceil, fix, floor, rint, round, trunc
+ *
+ * Note: Rounding operations are not defined for complex numbers.
+ * All functions throw TypeError for complex dtypes.
  */
 import { ArrayStorage } from '../core/storage';
 /**

package/dist/types/ops/sets.d.ts

@@ -35,4 +35,53 @@ export declare function setxor1d(ar1: ArrayStorage, ar2: ArrayStorage): ArraySto
  * Find the union of two arrays
  */
 export declare function union1d(ar1: ArrayStorage, ar2: ArrayStorage): ArrayStorage;
+/**
+ * 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: ArrayStorage, trim?: 'f' | 'b' | 'fb'): ArrayStorage;
+/**
+ * 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
+ */
+export declare function unique_all(x: ArrayStorage): {
+    values: ArrayStorage;
+    indices: ArrayStorage;
+    inverse_indices: ArrayStorage;
+    counts: ArrayStorage;
+};
+/**
+ * Find the unique elements of an array and their counts.
+ *
+ * @param x - Input array (flattened for uniqueness)
+ * @returns Object with values and counts
+ */
+export declare function unique_counts(x: ArrayStorage): {
+    values: ArrayStorage;
+    counts: ArrayStorage;
+};
+/**
+ * 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
+ */
+export declare function unique_inverse(x: ArrayStorage): {
+    values: ArrayStorage;
+    inverse_indices: ArrayStorage;
+};
+/**
+ * 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: ArrayStorage): ArrayStorage;
 //# sourceMappingURL=sets.d.ts.map

package/dist/types/ops/shape.d.ts

@@ -141,4 +141,17 @@ export declare function atleast2d(storages: ArrayStorage[]): ArrayStorage[];
  * Convert arrays to at least 3D
  */
 export declare function atleast3d(storages: ArrayStorage[]): ArrayStorage[];
+/**
+ * Alias for concatenate
+ */
+export declare function concat(storages: ArrayStorage[], axis?: number): ArrayStorage;
+/**
+ * Split an array into a sequence of sub-arrays along an axis (inverse of stack)
+ */
+export declare function unstack(storage: ArrayStorage, axis?: number): ArrayStorage[];
+/**
+ * Assemble an nd-array from nested lists of blocks
+ * For a simple list [a, b] of nD arrays, concatenates along the last axis (like np.block)
+ */
+export declare function block(storages: ArrayStorage[], _depth?: number): ArrayStorage;
 //# sourceMappingURL=shape.d.ts.map

package/dist/types/ops/statistics.d.ts

@@ -105,4 +105,26 @@ export declare function cov(m: ArrayStorage, y?: ArrayStorage, rowvar?: boolean,
  * @returns Correlation coefficient matrix
  */
 export declare function corrcoef(x: ArrayStorage, y?: ArrayStorage, rowvar?: boolean): ArrayStorage;
+/**
+ * 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: ArrayStorage, bins?: number | 'auto' | 'fd' | 'doane' | 'scott' | 'stone' | 'rice' | 'sturges' | 'sqrt', range?: [number, number], _weights?: ArrayStorage): ArrayStorage;
+/**
+ * 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: ArrayStorage, x?: ArrayStorage, dx?: number, axis?: number): ArrayStorage | number;
 //# sourceMappingURL=statistics.d.ts.map

package/dist/types/ops/trig.d.ts

@@ -11,6 +11,7 @@ import { ArrayStorage } from '../core/storage';
 /**
  * Sine of each element (element-wise)
  * NumPy behavior: Always promotes to float64 for integer types
+ * For complex: sin(a+bi) = sin(a)cosh(b) + i*cos(a)sinh(b)
  *
  * @param a - Input array storage (angles in radians)
  * @returns Result storage with sin applied
@@ -19,6 +20,7 @@ export declare function sin(a: ArrayStorage): ArrayStorage;
 /**
  * Cosine of each element (element-wise)
  * NumPy behavior: Always promotes to float64 for integer types
+ * For complex: cos(a+bi) = cos(a)cosh(b) - i*sin(a)sinh(b)
  *
  * @param a - Input array storage (angles in radians)
  * @returns Result storage with cos applied
@@ -27,6 +29,7 @@ export declare function cos(a: ArrayStorage): ArrayStorage;
 /**
  * Tangent of each element (element-wise)
  * NumPy behavior: Always promotes to float64 for integer types
+ * For complex: tan(a+bi) = (sin(2a) + i*sinh(2b)) / (cos(2a) + cosh(2b))
  *
  * @param a - Input array storage (angles in radians)
  * @returns Result storage with tan applied
@@ -35,6 +38,7 @@ export declare function tan(a: ArrayStorage): ArrayStorage;
 /**
  * Inverse sine of each element (element-wise)
  * NumPy behavior: Always promotes to float64 for integer types
+ * For complex: arcsin(z) = -i * log(iz + sqrt(1 - z²))
  *
  * @param a - Input array storage (values in range [-1, 1])
  * @returns Result storage with arcsin applied (radians)
@@ -43,6 +47,7 @@ export declare function arcsin(a: ArrayStorage): ArrayStorage;
 /**
  * Inverse cosine of each element (element-wise)
  * NumPy behavior: Always promotes to float64 for integer types
+ * For complex: arccos(z) = -i * log(z + i*sqrt(1 - z²))
  *
  * @param a - Input array storage (values in range [-1, 1])
  * @returns Result storage with arccos applied (radians)
@@ -51,6 +56,7 @@ export declare function arccos(a: ArrayStorage): ArrayStorage;
 /**
  * Inverse tangent of each element (element-wise)
  * NumPy behavior: Always promotes to float64 for integer types
+ * For complex: arctan(z) = (i/2) * log((1 - iz) / (1 + iz))
  *
  * @param a - Input array storage
  * @returns Result storage with arctan applied (radians)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "numpy-ts",
-  "version": "0.10.0",
-  "description": "Complete NumPy implementation for TypeScript and JavaScript (under construction)",
+  "version": "0.12.0",
+  "description": "Complete NumPy implementation for TypeScript and JavaScript (81% API coverage)",
   "main": "dist/numpy-ts.node.cjs",
   "browser": "dist/numpy-ts.browser.js",
   "module": "dist/numpy-ts.esm.js",
@@ -105,7 +105,7 @@
     "@vitest/coverage-v8": "^4.0.3",
     "chart.js": "^4.5.1",
     "chartjs-node-canvas": "^5.0.0",
-    "esbuild": "^0.25.11",
+    "esbuild": "^0.27.2",
     "eslint": "^9.38.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-prettier": "^5.0.1",