numpy-ts 0.10.0 → 0.12.0

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

@@ -6,6 +6,7 @@
  * @internal - This is not part of the public API
  */
 import { type DType, type TypedArray } from './dtype';
+import { Complex } from './complex';
 /**
  * Internal storage for NDArray data
  * Manages the underlying TypedArray and metadata
@@ -55,20 +56,30 @@ export declare class ArrayStorage {
     get isFContiguous(): boolean;
     /**
      * Get element at linear index (respects strides and offset)
+     * For complex dtypes, returns a Complex object.
      */
-    iget(linearIndex: number): number | bigint;
+    iget(linearIndex: number): number | bigint | Complex;
     /**
      * Set element at linear index (respects strides and offset)
+     * For complex dtypes, value can be a Complex object, {re, im} object, or number.
      */
-    iset(linearIndex: number, value: number | bigint): void;
+    iset(linearIndex: number, value: number | bigint | Complex | {
+        re: number;
+        im: number;
+    }): void;
     /**
      * Get element at multi-index position
+     * For complex dtypes, returns a Complex object.
      */
-    get(...indices: number[]): number | bigint;
+    get(...indices: number[]): number | bigint | Complex;
     /**
      * Set element at multi-index position
+     * For complex dtypes, value can be a Complex object, {re, im} object, or number.
      */
-    set(indices: number[], value: number | bigint): void;
+    set(indices: number[], value: number | bigint | Complex | {
+        re: number;
+        im: number;
+    }): void;
     /**
      * Create a deep copy of this storage
      */

package/dist/types/index.d.ts

@@ -3,22 +3,23 @@
  *
  * @module numpy-ts
  */
-export { NDArray, zeros, ones, array, arange, linspace, logspace, geomspace, eye, empty, full, identity, asarray, copy, zeros_like, ones_like, empty_like, full_like, asanyarray, ascontiguousarray, asfortranarray, diag, diagflat, frombuffer, fromfile, fromfunction, fromiter, fromstring, meshgrid, tri, tril, triu, vander, sqrt, power, pow, // alias for power
+export { Complex, type ComplexInput } from './core/complex';
+export { NDArray, zeros, ones, array, arange, linspace, logspace, geomspace, eye, empty, full, identity, asarray, copy, zeros_like, ones_like, empty_like, full_like, asanyarray, asarray_chkfinite, ascontiguousarray, asfortranarray, require, diag, diagflat, frombuffer, fromfile, fromfunction, fromiter, fromstring, meshgrid, tri, tril, triu, vander, sqrt, power, pow, // alias for power
 exp, exp2, expm1, log, log2, log10, log1p, logaddexp, logaddexp2, absolute, abs, // alias for absolute
 negative, sign, mod, divide, true_divide, // alias for divide
-floor_divide, positive, reciprocal, cbrt, fabs, divmod, square, remainder, heaviside, float_power, fmod, frexp, gcd, lcm, ldexp, modf, dot, trace, diagonal, kron, transpose, inner, outer, tensordot, einsum, linalg, sin, cos, tan, arcsin, asin, // alias for arcsin
+floor_divide, positive, reciprocal, cbrt, fabs, divmod, square, remainder, heaviside, float_power, fmod, frexp, gcd, lcm, ldexp, modf, clip, maximum, minimum, fmax, fmin, nan_to_num, interp, unwrap, sinc, i0, dot, trace, diagonal, kron, transpose, inner, outer, tensordot, einsum, vdot, vecdot, matrix_transpose, permute_dims, matvec, vecmat, linalg, sin, cos, tan, arcsin, asin, // alias for arcsin
 arccos, acos, // alias for arccos
 arctan, atan, // alias for arctan
 arctan2, atan2, // alias for arctan2
 hypot, degrees, radians, deg2rad, rad2deg, sinh, cosh, tanh, arcsinh, asinh, // alias for arcsinh
 arccosh, acosh, // alias for arccosh
 arctanh, atanh, // alias for arctanh
-swapaxes, moveaxis, concatenate, stack, vstack, hstack, dstack, split, array_split, vsplit, hsplit, tile, repeat, ravel, reshape, squeeze, expand_dims, flip, fliplr, flipud, rot90, roll, rollaxis, atleast_1d, atleast_2d, atleast_3d, dsplit, column_stack, row_stack, resize, append, delete_ as delete, insert, pad, broadcast_to, broadcast_arrays, broadcast_shapes, take, put, copyto, choose, array_equal, array_equiv, take_along_axis, put_along_axis, putmask, compress, select, place, fill_diagonal, diag_indices, diag_indices_from, tril_indices, tril_indices_from, triu_indices, triu_indices_from, mask_indices, indices, ix_, ravel_multi_index, unravel_index, cumsum, cumulative_sum, // alias for cumsum
+swapaxes, moveaxis, concatenate, stack, vstack, hstack, dstack, concat, unstack, block, split, array_split, vsplit, hsplit, tile, repeat, ravel, flatten, fill, item, tolist, tobytes, byteswap, view, tofile, reshape, squeeze, expand_dims, flip, fliplr, flipud, rot90, roll, rollaxis, atleast_1d, atleast_2d, atleast_3d, dsplit, column_stack, row_stack, resize, append, delete_ as delete, insert, pad, broadcast_to, broadcast_arrays, broadcast_shapes, take, put, iindex, bindex, copyto, choose, array_equal, array_equiv, take_along_axis, put_along_axis, putmask, compress, select, place, fill_diagonal, diag_indices, diag_indices_from, tril_indices, tril_indices_from, triu_indices, triu_indices_from, mask_indices, indices, ix_, ravel_multi_index, unravel_index, cumsum, cumulative_sum, // alias for cumsum
 cumprod, cumulative_prod, // alias for cumprod
 max, amax, // alias for max
 min, amin, // alias for min
-ptp, median, percentile, quantile, average, nansum, nanprod, nanmean, nanvar, nanstd, nanmin, nanmax, nanargmin, nanargmax, nancumsum, nancumprod, nanmedian, bitwise_and, bitwise_or, bitwise_xor, bitwise_not, invert, left_shift, right_shift, packbits, unpackbits, logical_and, logical_or, logical_not, logical_xor, isfinite, isinf, isnan, isnat, iscomplex, iscomplexobj, isreal, isrealobj, isneginf, isposinf, isfortran, real_if_close, isscalar, iterable, isdtype, promote_types, copysign, signbit, nextafter, spacing, sort, argsort, lexsort, partition, argpartition, sort_complex, nonzero, argwhere, flatnonzero, where, searchsorted, extract, count_nonzero, around, round_, // alias for around
-ceil, fix, floor, rint, round, trunc, unique, in1d, intersect1d, isin, setdiff1d, setxor1d, union1d, diff, ediff1d, gradient, cross, bincount, digitize, histogram, histogram2d, histogramdd, correlate, convolve, cov, corrcoef, } from './core/ndarray';
+ptp, median, percentile, quantile, average, nansum, nanprod, nanmean, nanvar, nanstd, nanmin, nanmax, nanargmin, nanargmax, nancumsum, nancumprod, nanmedian, nanquantile, nanpercentile, bitwise_and, bitwise_or, bitwise_xor, bitwise_not, invert, left_shift, right_shift, packbits, unpackbits, bitwise_count, bitwise_invert, bitwise_left_shift, bitwise_right_shift, logical_and, logical_or, logical_not, logical_xor, isfinite, isinf, isnan, isnat, iscomplex, iscomplexobj, isreal, isrealobj, real, imag, conj, conjugate, angle, isneginf, isposinf, isfortran, real_if_close, isscalar, iterable, isdtype, promote_types, copysign, signbit, nextafter, spacing, sort, argsort, lexsort, partition, argpartition, sort_complex, nonzero, argwhere, flatnonzero, where, searchsorted, extract, count_nonzero, around, round_, // alias for around
+ceil, fix, floor, rint, round, trunc, unique, in1d, intersect1d, isin, setdiff1d, setxor1d, union1d, trim_zeros, unique_all, unique_counts, unique_inverse, unique_values, diff, ediff1d, gradient, cross, bincount, digitize, histogram, histogram2d, histogramdd, correlate, convolve, cov, corrcoef, histogram_bin_edges, trapezoid, apply_along_axis, apply_over_axes, may_share_memory, shares_memory, ndim, shape, size, geterr, seterr, can_cast, common_type, result_type, min_scalar_type, issubdtype, typename, mintypecode, poly, polyadd, polyder, polydiv, polyfit, polyint, polymul, polysub, polyval, roots, } from './core/ndarray';
 export { parseNpy, serializeNpy, parseNpyHeader, parseNpyData, UnsupportedDTypeError, InvalidNpyError, SUPPORTED_DTYPES, DTYPE_TO_DESCR, type NpyHeader, type NpyMetadata, type NpyVersion, parseNpz, parseNpzSync, loadNpz, loadNpzSync, serializeNpz, serializeNpzSync, type NpzParseOptions, type NpzParseResult, type NpzSerializeOptions, } from './io';
 import * as randomOps from './ops/random';
 import { ArrayStorage } from './core/storage';

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

@@ -112,4 +112,69 @@ export declare function unravel_index(indices: ArrayStorage | number, shape: num
  * @param wrap - Whether to wrap for tall matrices
  */
 export declare function fill_diagonal(a: ArrayStorage, val: ArrayStorage | number, wrap?: boolean): void;
+/**
+ * Apply a function along a given axis.
+ *
+ * @param arr - Input array storage
+ * @param axis - Axis along which to apply the function
+ * @param func1d - Function that takes a 1D array and returns a 1D array or scalar
+ * @returns Result array
+ */
+export declare function apply_along_axis(arr: ArrayStorage, axis: number, func1d: (slice: ArrayStorage) => ArrayStorage | number): ArrayStorage;
+/**
+ * Apply a function over multiple axes.
+ *
+ * @param arr - Input array storage
+ * @param func - Function that operates on an array
+ * @param axes - Axes over which to apply the function
+ * @returns Result array
+ */
+export declare function apply_over_axes(arr: ArrayStorage, func: (a: ArrayStorage, axis: number) => ArrayStorage, axes: number[]): ArrayStorage;
+/**
+ * Check if two arrays may share memory.
+ *
+ * In JavaScript, we can't directly check memory sharing like in Python.
+ * This is a conservative implementation that returns true if they share
+ * the same underlying buffer.
+ *
+ * @param a - First array storage
+ * @param b - Second array storage
+ * @returns True if arrays may share memory
+ */
+export declare function may_share_memory(a: ArrayStorage, b: ArrayStorage): boolean;
+/**
+ * Check if two arrays share memory.
+ *
+ * This is the same as may_share_memory in our implementation since
+ * JavaScript doesn't have the same memory model as Python/NumPy.
+ *
+ * @param a - First array storage
+ * @param b - Second array storage
+ * @returns True if arrays share memory
+ */
+export declare function shares_memory(a: ArrayStorage, b: ArrayStorage): boolean;
+type ErrorMode = 'ignore' | 'warn' | 'raise' | 'call' | 'print' | 'log';
+export interface FloatErrorState {
+    divide: ErrorMode;
+    over: ErrorMode;
+    under: ErrorMode;
+    invalid: ErrorMode;
+}
+/**
+ * Get the current floating-point error handling.
+ *
+ * @returns Current error handling settings
+ */
+export declare function geterr(): FloatErrorState;
+/**
+ * Set how floating-point errors are handled.
+ *
+ * @param all - Set all error modes at once (optional)
+ * @param divide - Treatment for division by zero
+ * @param over - Treatment for floating-point overflow
+ * @param under - Treatment for floating-point underflow
+ * @param invalid - Treatment for invalid floating-point operation
+ * @returns Previous error handling settings
+ */
+export declare function seterr(all?: ErrorMode, divide?: ErrorMode, over?: ErrorMode, under?: ErrorMode, invalid?: ErrorMode): FloatErrorState;
 //# sourceMappingURL=advanced.d.ts.map

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

@@ -37,6 +37,8 @@ export declare function multiply(a: ArrayStorage, b: ArrayStorage | number): Arr
  *
  * NumPy behavior: Integer division always promotes to float
  * Type promotion rules:
+ * - complex128 + anything → complex128
+ * - complex64 + float32/int → complex64
  * - float64 + anything → float64
  * - float32 + integer → float32
  * - integer + integer → float64
@@ -100,6 +102,7 @@ export declare function positive(a: ArrayStorage): ArrayStorage;
 /**
  * Reciprocal (1/x) of each element
  * NumPy behavior: Always promotes to float64 for integer types
+ * For complex: 1/z = z̄/|z|² = (re - i*im) / (re² + im²)
  *
  * @param a - Input array storage
  * @returns Result storage with reciprocal values
@@ -133,6 +136,7 @@ export declare function divmod(a: ArrayStorage, b: ArrayStorage | number): [Arra
 /**
  * Element-wise square of each element
  * NumPy behavior: x**2
+ * For complex: z² = (re + i*im)² = (re² - im²) + i*(2*re*im)
  *
  * @param a - Input array storage
  * @returns Result storage with squared values
@@ -208,4 +212,103 @@ export declare function ldexp(x1: ArrayStorage, x2: ArrayStorage | number): Arra
  * @returns Tuple of [fractional, integral] arrays
  */
 export declare function modf(x: ArrayStorage): [ArrayStorage, ArrayStorage];
+/**
+ * Clip (limit) the values in an array
+ * Given an interval, values outside the interval are clipped to the interval edges.
+ *
+ * @param a - Input array storage
+ * @param a_min - Minimum value (null to not clip minimum)
+ * @param a_max - Maximum value (null to not clip maximum)
+ * @returns Clipped array storage
+ */
+export declare function clip(a: ArrayStorage, a_min: number | ArrayStorage | null, a_max: number | ArrayStorage | null): ArrayStorage;
+/**
+ * Element-wise maximum of array elements
+ *
+ * @param x1 - First array storage
+ * @param x2 - Second array storage or scalar
+ * @returns Element-wise maximum
+ */
+export declare function maximum(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
+/**
+ * Element-wise minimum of array elements
+ *
+ * @param x1 - First array storage
+ * @param x2 - Second array storage or scalar
+ * @returns Element-wise minimum
+ */
+export declare function minimum(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
+/**
+ * Element-wise maximum of array elements, ignoring NaNs
+ *
+ * @param x1 - First array storage
+ * @param x2 - Second array storage or scalar
+ * @returns Element-wise maximum, NaN-aware
+ */
+export declare function fmax(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
+/**
+ * Element-wise minimum of array elements, ignoring NaNs
+ *
+ * @param x1 - First array storage
+ * @param x2 - Second array storage or scalar
+ * @returns Element-wise minimum, NaN-aware
+ */
+export declare function fmin(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
+/**
+ * Replace NaN with zero and Inf with large finite numbers
+ *
+ * @param x - Input array storage
+ * @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: ArrayStorage, nan?: number, posinf?: number, neginf?: number): ArrayStorage;
+/**
+ * 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: ArrayStorage, xp: ArrayStorage, fp: ArrayStorage, left?: number, right?: number): ArrayStorage;
+/**
+ * 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: ArrayStorage, discont?: number, axis?: number, period?: number): ArrayStorage;
+/**
+ * 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: ArrayStorage): ArrayStorage;
+/**
+ * Modified Bessel function of the first kind, order 0
+ *
+ * Uses polynomial approximation.
+ *
+ * @param x - Input array
+ * @returns Array of I0 values
+ */
+export declare function i0(x: ArrayStorage): ArrayStorage;
 //# sourceMappingURL=arithmetic.d.ts.map

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

@@ -88,4 +88,34 @@ export declare function packbits(a: ArrayStorage, axis?: number, bitorder?: 'big
  * @returns Unpacked uint8 array of 0s and 1s
  */
 export declare function unpackbits(a: ArrayStorage, axis?: number, count?: number, bitorder?: 'big' | 'little'): ArrayStorage;
+/**
+ * Count the number of 1-bits in each element (population count).
+ *
+ * @param x - Input array (must be integer type)
+ * @returns Array with population count for each element
+ */
+export declare function bitwise_count(x: ArrayStorage): ArrayStorage;
+/**
+ * Bitwise invert (alias for bitwise_not)
+ *
+ * @param x - Input array (must be integer type)
+ * @returns Result storage with bitwise NOT values
+ */
+export declare function bitwise_invert(x: ArrayStorage): ArrayStorage;
+/**
+ * Bitwise left shift (alias for left_shift)
+ *
+ * @param x1 - Input array (must be integer type)
+ * @param x2 - Shift amount (array or scalar)
+ * @returns Result storage with left-shifted values
+ */
+export declare function bitwise_left_shift(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
+/**
+ * Bitwise right shift (alias for right_shift)
+ *
+ * @param x1 - Input array (must be integer type)
+ * @param x2 - Shift amount (array or scalar)
+ * @returns Result storage with right-shifted values
+ */
+export declare function bitwise_right_shift(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
 //# sourceMappingURL=bitwise.d.ts.map

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

@@ -8,26 +8,32 @@
 import { ArrayStorage } from '../core/storage';
 /**
  * Element-wise greater than comparison (a > b)
+ * For complex: uses lexicographic ordering (real first, then imaginary)
  */
 export declare function greater(a: ArrayStorage, b: ArrayStorage | number): ArrayStorage;
 /**
  * Element-wise greater than or equal comparison (a >= b)
+ * For complex: uses lexicographic ordering (real first, then imaginary)
  */
 export declare function greaterEqual(a: ArrayStorage, b: ArrayStorage | number): ArrayStorage;
 /**
  * Element-wise less than comparison (a < b)
+ * For complex: uses lexicographic ordering (real first, then imaginary)
  */
 export declare function less(a: ArrayStorage, b: ArrayStorage | number): ArrayStorage;
 /**
  * Element-wise less than or equal comparison (a <= b)
+ * For complex: uses lexicographic ordering (real first, then imaginary)
  */
 export declare function lessEqual(a: ArrayStorage, b: ArrayStorage | number): ArrayStorage;
 /**
  * Element-wise equality comparison (a == b)
+ * For complex: both real and imaginary parts must be equal
  */
 export declare function equal(a: ArrayStorage, b: ArrayStorage | number): ArrayStorage;
 /**
  * Element-wise inequality comparison (a != b)
+ * For complex: either real or imaginary parts must differ
  */
 export declare function notEqual(a: ArrayStorage, b: ArrayStorage | number): ArrayStorage;
 /**

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

@@ -0,0 +1,65 @@
+/**
+ * Complex number operations
+ *
+ * Pure functions for complex array operations:
+ * real, imag, conj, angle
+ *
+ * @module ops/complex
+ */
+import { ArrayStorage } from '../core/storage';
+/**
+ * Return the real part of complex argument.
+ *
+ * For complex arrays, returns the real components.
+ * For real arrays, returns a copy of the input.
+ *
+ * @param a - Input array storage
+ * @returns Array with real parts (float64 or float32 for complex, same dtype for real)
+ */
+export declare function real(a: ArrayStorage): ArrayStorage;
+/**
+ * Return the imaginary part of complex argument.
+ *
+ * For complex arrays, returns the imaginary components.
+ * For real arrays, returns zeros.
+ *
+ * @param a - Input array storage
+ * @returns Array with imaginary parts
+ */
+export declare function imag(a: ArrayStorage): ArrayStorage;
+/**
+ * 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 a - Input array storage
+ * @returns Complex conjugate array
+ */
+export declare function conj(a: ArrayStorage): ArrayStorage;
+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 a - Input array storage
+ * @param deg - Return angle in degrees if true (default: false, returns radians)
+ * @returns Array with angles in radians (or degrees)
+ */
+export declare function angle(a: ArrayStorage, deg?: boolean): ArrayStorage;
+/**
+ * Return the absolute value (magnitude) for complex arrays.
+ *
+ * For complex: |z| = sqrt(re² + im²)
+ * For real: |x| = abs(x)
+ *
+ * This is a helper that can be called from arithmetic.absolute
+ *
+ * @param a - Input array storage
+ * @returns Array with magnitudes
+ */
+export declare function complexAbs(a: ArrayStorage): ArrayStorage;
+//# sourceMappingURL=complex.d.ts.map

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

@@ -11,6 +11,7 @@ import { ArrayStorage } from '../core/storage';
 /**
  * Square root of each element
  * NumPy behavior: Always promotes to float64 for integer types
+ * For complex: sqrt(a+bi) = sqrt((|z|+a)/2) + sign(b)*i*sqrt((|z|-a)/2)
  *
  * @param a - Input array storage
  * @returns Result storage with sqrt applied
@@ -19,6 +20,7 @@ export declare function sqrt(a: ArrayStorage): ArrayStorage;
 /**
  * Raise elements to power
  * NumPy behavior: Promotes to float64 for integer types with non-integer exponents
+ * For complex: z^n = |z|^n * (cos(n*θ) + i*sin(n*θ)) where θ = atan2(im, re)
  *
  * @param a - Base array storage
  * @param b - Exponent (array storage or scalar)
@@ -28,6 +30,7 @@ export declare function power(a: ArrayStorage, b: ArrayStorage | number): ArrayS
 /**
  * Natural exponential function (e^x) for each element
  * NumPy behavior: Always promotes to float64 for integer types
+ * For complex: exp(a+bi) = e^a * (cos(b) + i*sin(b))
  *
  * @param a - Input array storage
  * @returns Result storage with exp applied
@@ -36,6 +39,7 @@ export declare function exp(a: ArrayStorage): ArrayStorage;
 /**
  * Base-2 exponential function (2^x) for each element
  * NumPy behavior: Always promotes to float64 for integer types
+ * For complex: 2^z = exp(z * ln(2))
  *
  * @param a - Input array storage
  * @returns Result storage with 2^x applied
@@ -45,6 +49,7 @@ export declare function exp2(a: ArrayStorage): ArrayStorage;
  * Exponential minus one (e^x - 1) for each element
  * More accurate than exp(x) - 1 for small x
  * NumPy behavior: Always promotes to float64 for integer types
+ * For complex: expm1(z) = exp(z) - 1
  *
  * @param a - Input array storage
  * @returns Result storage with expm1 applied
@@ -53,6 +58,7 @@ export declare function expm1(a: ArrayStorage): ArrayStorage;
 /**
  * Natural logarithm (ln) for each element
  * NumPy behavior: Always promotes to float64 for integer types
+ * For complex: log(a+bi) = ln|z| + i*arg(z) = ln(sqrt(a²+b²)) + i*atan2(b,a)
  *
  * @param a - Input array storage
  * @returns Result storage with log applied
@@ -61,6 +67,7 @@ export declare function log(a: ArrayStorage): ArrayStorage;
 /**
  * Base-2 logarithm for each element
  * NumPy behavior: Always promotes to float64 for integer types
+ * For complex: log2(z) = log(z) / ln(2)
  *
  * @param a - Input array storage
  * @returns Result storage with log2 applied
@@ -69,6 +76,7 @@ export declare function log2(a: ArrayStorage): ArrayStorage;
 /**
  * Base-10 logarithm for each element
  * NumPy behavior: Always promotes to float64 for integer types
+ * For complex: log10(z) = log(z) / ln(10)
  *
  * @param a - Input array storage
  * @returns Result storage with log10 applied
@@ -78,6 +86,7 @@ export declare function log10(a: ArrayStorage): ArrayStorage;
  * Natural logarithm of (1 + x) for each element
  * More accurate than log(1 + x) for small x
  * NumPy behavior: Always promotes to float64 for integer types
+ * For complex: log1p(z) = log(1 + z)
  *
  * @param a - Input array storage
  * @returns Result storage with log1p applied

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

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