numpy-ts 0.9.0 → 0.11.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,7 +3,47 @@
  *
  * @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, exp, exp2, expm1, log, log2, log10, log1p, logaddexp, logaddexp2, absolute, negative, sign, mod, floor_divide, positive, reciprocal, cbrt, fabs, divmod, square, remainder, heaviside, dot, trace, diagonal, kron, transpose, inner, outer, tensordot, einsum, linalg, sin, cos, tan, arcsin, arccos, arctan, arctan2, hypot, degrees, radians, deg2rad, rad2deg, sinh, cosh, tanh, arcsinh, arccosh, 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, choose, array_equal, array_equiv, take_along_axis, put_along_axis, putmask, compress, select, place, 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, cumprod, 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, sort, argsort, lexsort, partition, argpartition, sort_complex, nonzero, flatnonzero, where, searchsorted, extract, count_nonzero, around, ceil, fix, floor, rint, round, trunc, unique, in1d, intersect1d, isin, setdiff1d, setxor1d, union1d, diff, ediff1d, gradient, cross, } from './core/ndarray';
+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, ascontiguousarray, asfortranarray, 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
+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, 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, 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, diff, ediff1d, gradient, cross, bincount, digitize, histogram, histogram2d, histogramdd, correlate, convolve, cov, corrcoef, } 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';
+import { NDArray as NDArrayClass } from './core/ndarray';
+import { DType } from './core/dtype';
+export declare const random: {
+    seed: typeof randomOps.seed;
+    random: (size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    rand: (...shape: number[]) => number | ArrayStorage | NDArrayClass;
+    randn: (...shape: number[]) => number | ArrayStorage | NDArrayClass;
+    randint: (low: number, high?: number | null, size?: number | number[], dtype?: DType) => number | ArrayStorage | NDArrayClass;
+    uniform: (low?: number, high?: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    normal: (loc?: number, scale?: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    standard_normal: (size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    exponential: (scale?: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    poisson: (lam?: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    binomial: (n: number, p: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    choice: (a: number | ArrayStorage, size?: number | number[], replace?: boolean, p?: ArrayStorage | number[]) => number | ArrayStorage | NDArrayClass;
+    permutation: (x: number | ArrayStorage) => ArrayStorage | NDArrayClass;
+    shuffle: typeof randomOps.shuffle;
+    get_state: typeof randomOps.get_state;
+    set_state: typeof randomOps.set_state;
+    default_rng: typeof randomOps.default_rng;
+    Generator: typeof randomOps.Generator;
+};
 export declare const __version__: string;
 //# sourceMappingURL=index.d.ts.map

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

@@ -105,4 +105,11 @@ export declare function ravel_multi_index(multi_index: ArrayStorage[], dims: num
  * Convert flat index array to tuple of coordinate arrays
  */
 export declare function unravel_index(indices: ArrayStorage | number, shape: number[], order?: 'C' | 'F'): ArrayStorage[];
+/**
+ * Fill the main diagonal of a given array (modifies in-place)
+ * @param a - Array storage (at least 2D)
+ * @param val - Value or array of values to fill diagonal with
+ * @param wrap - Whether to wrap for tall matrices
+ */
+export declare function fill_diagonal(a: ArrayStorage, val: ArrayStorage | number, wrap?: boolean): void;
 //# 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
@@ -159,4 +163,53 @@ export declare function remainder(a: ArrayStorage, b: ArrayStorage | number): Ar
  * @returns Result storage with heaviside values
  */
 export declare function heaviside(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
+/**
+ * First array raised to power of second, always promoting to float
+ * @param x1 - Base values
+ * @param x2 - Exponent values
+ * @returns Result in float64
+ */
+export declare function float_power(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
+/**
+ * Element-wise remainder of division (fmod)
+ * Unlike mod/remainder, fmod matches C fmod behavior
+ * @param x1 - Dividend
+ * @param x2 - Divisor
+ * @returns Remainder
+ */
+export declare function fmod(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
+/**
+ * Decompose floating point numbers into mantissa and exponent
+ * Returns [mantissa, exponent] where x = mantissa * 2^exponent
+ * @param x - Input array
+ * @returns Tuple of [mantissa, exponent] arrays
+ */
+export declare function frexp(x: ArrayStorage): [ArrayStorage, ArrayStorage];
+/**
+ * Greatest common divisor
+ * @param x1 - First array
+ * @param x2 - Second array or scalar
+ * @returns GCD
+ */
+export declare function gcd(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
+/**
+ * Least common multiple
+ * @param x1 - First array
+ * @param x2 - Second array or scalar
+ * @returns LCM
+ */
+export declare function lcm(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
+/**
+ * Returns x1 * 2^x2, element-wise
+ * @param x1 - Mantissa
+ * @param x2 - Exponent
+ * @returns Result
+ */
+export declare function ldexp(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
+/**
+ * Return fractional and integral parts of array
+ * @param x - Input array
+ * @returns Tuple of [fractional, integral] arrays
+ */
+export declare function modf(x: ArrayStorage): [ArrayStorage, ArrayStorage];
 //# sourceMappingURL=arithmetic.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

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.
  *

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

@@ -0,0 +1,219 @@
+/**
+ * Logic operations
+ *
+ * Pure functions for element-wise logical operations:
+ * logical_and, logical_or, logical_not, logical_xor,
+ * isfinite, isinf, isnan, isnat, copysign, signbit, nextafter, spacing
+ *
+ * These operations convert values to boolean (non-zero = true, zero = false)
+ * and return boolean arrays (dtype: 'bool').
+ */
+import { ArrayStorage } from '../core/storage';
+import { type DType } from '../core/dtype';
+/**
+ * Logical AND of two arrays or array and scalar
+ *
+ * Returns a boolean array where each element is the logical AND
+ * of corresponding elements (non-zero = true, zero = false).
+ *
+ * @param a - First array storage
+ * @param b - Second array storage or scalar
+ * @returns Boolean result storage
+ */
+export declare function logical_and(a: ArrayStorage, b: ArrayStorage | number): ArrayStorage;
+/**
+ * Logical OR of two arrays or array and scalar
+ *
+ * Returns a boolean array where each element is the logical OR
+ * of corresponding elements (non-zero = true, zero = false).
+ *
+ * @param a - First array storage
+ * @param b - Second array storage or scalar
+ * @returns Boolean result storage
+ */
+export declare function logical_or(a: ArrayStorage, b: ArrayStorage | number): ArrayStorage;
+/**
+ * Logical NOT of an array
+ *
+ * Returns a boolean array where each element is the logical NOT
+ * of the input (non-zero = false, zero = true).
+ *
+ * @param a - Input array storage
+ * @returns Boolean result storage
+ */
+export declare function logical_not(a: ArrayStorage): ArrayStorage;
+/**
+ * Logical XOR of two arrays or array and scalar
+ *
+ * Returns a boolean array where each element is the logical XOR
+ * of corresponding elements (non-zero = true, zero = false).
+ *
+ * @param a - First array storage
+ * @param b - Second array storage or scalar
+ * @returns Boolean result storage
+ */
+export declare function logical_xor(a: ArrayStorage, b: ArrayStorage | number): ArrayStorage;
+/**
+ * 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
+ */
+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
+ */
+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
+ */
+export declare function isnan(a: ArrayStorage): ArrayStorage;
+/**
+ * Test element-wise for NaT (Not a Time)
+ *
+ * In NumPy, NaT is the datetime equivalent of NaN.
+ * Since we don't have datetime support, this always returns false.
+ *
+ * @param a - Input array storage
+ * @returns Boolean result storage (all false)
+ */
+export declare function isnat(a: ArrayStorage): ArrayStorage;
+/**
+ * Change the sign of x1 to that of x2, element-wise
+ *
+ * Returns a value with the magnitude of x1 and the sign of x2.
+ *
+ * @param x1 - Values to change sign of (magnitude source)
+ * @param x2 - Values whose sign is used (sign source)
+ * @returns Array with magnitude from x1 and sign from x2
+ */
+export declare function copysign(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
+/**
+ * Returns element-wise True where signbit is set (less than zero)
+ *
+ * @param a - Input array storage
+ * @returns Boolean result storage
+ */
+export declare function signbit(a: ArrayStorage): ArrayStorage;
+/**
+ * Return the next floating-point value after x1 towards x2, element-wise
+ *
+ * @param x1 - Values to find the next representable value of
+ * @param x2 - Direction to look in for the next representable value
+ * @returns Array of next representable values
+ */
+export declare function nextafter(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
+/**
+ * Return the distance between x and the nearest adjacent number
+ *
+ * This is the difference between x and the next representable floating-point value.
+ *
+ * @param a - Input array storage
+ * @returns Array of spacing values
+ */
+export declare function spacing(a: ArrayStorage): ArrayStorage;
+/**
+ * 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
+ */
+export declare function iscomplex(a: ArrayStorage): ArrayStorage;
+/**
+ * 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;
+/**
+ * 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
+ */
+export declare function isreal(a: ArrayStorage): ArrayStorage;
+/**
+ * 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;
+/**
+ * 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
+ */
+export declare function isposinf(a: ArrayStorage): ArrayStorage;
+/**
+ * Check if array is Fortran contiguous (column-major order)
+ * @param a - Input array storage
+ * @returns true if F-contiguous
+ */
+export declare function isfortran(a: ArrayStorage): boolean;
+/**
+ * Returns complex array with complex parts close to zero set to real
+ * Since numpy-ts doesn't support complex numbers, returns copy
+ * @param a - Input array storage
+ * @param _tol - Tolerance (unused, for API compatibility)
+ * @returns Copy of input array
+ */
+export declare function real_if_close(a: ArrayStorage, tol?: number): ArrayStorage;
+/**
+ * Check if element is a scalar type
+ * @param val - Value to check
+ * @returns true if scalar
+ */
+export declare function isscalar(val: unknown): boolean;
+/**
+ * Check if object is iterable
+ * @param obj - Object to check
+ * @returns true if iterable
+ */
+export declare function iterable(obj: unknown): boolean;
+/**
+ * Check if dtype meets specified criteria
+ * @param dtype - Dtype to check
+ * @param kind - Kind of dtype ('b' bool, 'i' int, 'u' uint, 'f' float)
+ * @returns true if dtype matches kind
+ */
+export declare function isdtype(dtype: DType, kind: string): boolean;
+/**
+ * Find the dtype that can represent both input dtypes
+ * @param dtype1 - First dtype
+ * @param dtype2 - Second dtype
+ * @returns Promoted dtype
+ */
+export declare function promote_types(dtype1: DType, dtype2: DType): DType;
+//# sourceMappingURL=logic.d.ts.map