numpy-ts 0.8.0 → 0.10.0

package/dist/types/index.d.ts

@@ -3,7 +3,46 @@
  *
  * @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, absolute, negative, sign, mod, floor_divide, positive, reciprocal, cbrt, fabs, divmod, square, remainder, heaviside, dot, trace, diagonal, kron, transpose, inner, outer, tensordot, einsum, 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, } from './core/ndarray';
+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, 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';
 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

@@ -159,4 +159,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/exponential.d.ts

@@ -2,7 +2,7 @@
  * Exponential, logarithmic, and power operations
  *
  * Pure functions for element-wise exponential operations:
- * exp, log, sqrt, power, etc.
+ * exp, exp2, expm1, log, log2, log10, log1p, logaddexp, logaddexp2, sqrt, power
  *
  * These functions are used by NDArray methods but are separated
  * to keep the codebase modular and testable.
@@ -25,4 +25,82 @@ export declare function sqrt(a: ArrayStorage): ArrayStorage;
  * @returns Result storage with power applied
  */
 export declare function power(a: ArrayStorage, b: ArrayStorage | number): ArrayStorage;
+/**
+ * Natural exponential function (e^x) for each element
+ * NumPy behavior: Always promotes to float64 for integer types
+ *
+ * @param a - Input array storage
+ * @returns Result storage with exp applied
+ */
+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
+ *
+ * @param a - Input array storage
+ * @returns Result storage with 2^x applied
+ */
+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
+ *
+ * @param a - Input array storage
+ * @returns Result storage with expm1 applied
+ */
+export declare function expm1(a: ArrayStorage): ArrayStorage;
+/**
+ * Natural logarithm (ln) for each element
+ * NumPy behavior: Always promotes to float64 for integer types
+ *
+ * @param a - Input array storage
+ * @returns Result storage with log applied
+ */
+export declare function log(a: ArrayStorage): ArrayStorage;
+/**
+ * Base-2 logarithm for each element
+ * NumPy behavior: Always promotes to float64 for integer types
+ *
+ * @param a - Input array storage
+ * @returns Result storage with log2 applied
+ */
+export declare function log2(a: ArrayStorage): ArrayStorage;
+/**
+ * Base-10 logarithm for each element
+ * NumPy behavior: Always promotes to float64 for integer types
+ *
+ * @param a - Input array storage
+ * @returns Result storage with log10 applied
+ */
+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
+ *
+ * @param a - Input array storage
+ * @returns Result storage with log1p applied
+ */
+export declare function log1p(a: ArrayStorage): ArrayStorage;
+/**
+ * Logarithm of the sum of exponentials: log(exp(x1) + exp(x2))
+ * More numerically stable than computing the expression directly
+ * NumPy behavior: Always promotes to float64 for integer types
+ *
+ * @param x1 - First input array storage
+ * @param x2 - Second input array storage (or scalar)
+ * @returns Result storage with logaddexp applied
+ */
+export declare function logaddexp(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
+/**
+ * Logarithm base 2 of the sum of exponentials: log2(2^x1 + 2^x2)
+ * More numerically stable than computing the expression directly
+ * NumPy behavior: Always promotes to float64 for integer types
+ *
+ * @param x1 - First input array storage
+ * @param x2 - Second input array storage (or scalar)
+ * @returns Result storage with logaddexp2 applied
+ */
+export declare function logaddexp2(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
 //# sourceMappingURL=exponential.d.ts.map

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

@@ -0,0 +1,57 @@
+/**
+ * Gradient and difference operations
+ *
+ * Pure functions for computing gradients and differences:
+ * gradient, diff, ediff1d, cross
+ *
+ * These functions are used by NDArray methods but are separated
+ * to keep the codebase modular and testable.
+ */
+import { ArrayStorage } from '../core/storage';
+/**
+ * Calculate the n-th discrete difference along the given axis.
+ *
+ * The first difference is given by out[i] = a[i+1] - a[i] along the given axis.
+ * Higher differences are calculated by using diff recursively.
+ *
+ * @param a - Input array storage
+ * @param n - Number of times values are differenced (default: 1)
+ * @param axis - Axis along which to compute difference (default: -1, last axis)
+ * @returns Result storage with differences
+ */
+export declare function diff(a: ArrayStorage, n?: number, axis?: number): ArrayStorage;
+/**
+ * The differences between consecutive elements of a flattened array.
+ *
+ * @param ary - Input array storage
+ * @param to_end - Number(s) to append at the end of the returned differences
+ * @param to_begin - Number(s) to prepend at the beginning of the returned differences
+ * @returns Array of differences with optional prepend/append values
+ */
+export declare function ediff1d(ary: ArrayStorage, to_end?: number[] | null, to_begin?: number[] | null): ArrayStorage;
+/**
+ * Return the gradient of an N-dimensional array.
+ *
+ * The gradient is computed using second order accurate central differences in the interior
+ * and first order accurate one-sided (forward or backwards) differences at the boundaries.
+ *
+ * @param f - Input array storage
+ * @param varargs - Spacing between values (scalar or array per dimension)
+ * @param axis - Axis or axes along which to compute gradient (default: all axes)
+ * @returns Array of gradients (one per axis) or single gradient if one axis
+ */
+export declare function gradient(f: ArrayStorage, varargs?: number | number[], axis?: number | number[] | null): ArrayStorage | ArrayStorage[];
+/**
+ * Return the cross product of two (arrays of) vectors.
+ *
+ * The cross product of a and b in R^3 is a vector perpendicular to both a and b.
+ *
+ * @param a - First input array (components of first vector(s))
+ * @param b - Second input array (components of second vector(s))
+ * @param axisa - Axis of a that defines the vector(s) (default: -1)
+ * @param axisb - Axis of b that defines the vector(s) (default: -1)
+ * @param axisc - Axis of c containing the cross product vector(s) (default: -1)
+ * @returns Cross product array
+ */
+export declare function cross(a: ArrayStorage, b: ArrayStorage, axisa?: number, axisb?: number, _axisc?: number): ArrayStorage;
+//# sourceMappingURL=gradient.d.ts.map

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

@@ -143,4 +143,224 @@ export declare function einsum(subscripts: string, ...operands: ArrayStorage[]):
  * @returns Kronecker product of a and b
  */
 export declare function kron(a: ArrayStorage, b: ArrayStorage): ArrayStorage;
+/**
+ * Cross product of two vectors.
+ *
+ * For 3D vectors: returns the cross product vector
+ * For 2D vectors: returns the scalar z-component of the cross product
+ *
+ * @param a - First input array
+ * @param b - Second input array
+ * @param axisa - Axis of a that defines the vectors (default: -1)
+ * @param axisb - Axis of b that defines the vectors (default: -1)
+ * @param axisc - Axis of c containing the cross product vectors (default: -1)
+ * @param axis - If defined, the axis of a, b and c that defines the vectors
+ * @returns Cross product of a and b
+ */
+export declare function cross(a: ArrayStorage, b: ArrayStorage, axisa?: number, axisb?: number, axisc?: number, axis?: number): ArrayStorage | number;
+/**
+ * Vector norm.
+ *
+ * @param x - Input vector or array
+ * @param ord - Order of the norm (default: 2)
+ *              - Infinity: max(abs(x))
+ *              - -Infinity: min(abs(x))
+ *              - 0: sum(x != 0)
+ *              - Other: sum(abs(x)^ord)^(1/ord)
+ * @param axis - Axis along which to compute (flattened if not specified)
+ * @param keepdims - Keep reduced dimensions
+ * @returns Vector norm
+ */
+export declare function vector_norm(x: ArrayStorage, ord?: number | 'fro' | 'nuc', axis?: number | null, keepdims?: boolean): ArrayStorage | number;
+/**
+ * Matrix norm.
+ *
+ * @param x - Input 2D array
+ * @param ord - Order of the norm:
+ *              - 'fro': Frobenius norm (default)
+ *              - 'nuc': Nuclear norm (sum of singular values)
+ *              - 1: Max column sum (max(sum(abs(x), axis=0)))
+ *              - -1: Min column sum (min(sum(abs(x), axis=0)))
+ *              - 2: Largest singular value
+ *              - -2: Smallest singular value
+ *              - Infinity: Max row sum (max(sum(abs(x), axis=1)))
+ *              - -Infinity: Min row sum (min(sum(abs(x), axis=1)))
+ * @param keepdims - Keep reduced dimensions
+ * @returns Matrix norm
+ */
+export declare function matrix_norm(x: ArrayStorage, ord?: number | 'fro' | 'nuc', keepdims?: boolean): ArrayStorage | number;
+/**
+ * General norm function (for both vectors and matrices).
+ *
+ * @param x - Input array
+ * @param ord - Order of the norm (default: 'fro' for 2D, 2 for 1D)
+ * @param axis - Axis or axes along which to compute
+ * @param keepdims - Keep reduced dimensions
+ * @returns Norm
+ */
+export declare function norm(x: ArrayStorage, ord?: number | 'fro' | 'nuc' | null, axis?: number | [number, number] | null, keepdims?: boolean): ArrayStorage | number;
+/**
+ * QR decomposition using Householder reflections.
+ *
+ * @param a - Input matrix (m x n)
+ * @param mode - 'reduced' (default), 'complete', 'r', or 'raw'
+ * @returns { q, r } where A = Q @ R
+ */
+export declare function qr(a: ArrayStorage, mode?: 'reduced' | 'complete' | 'r' | 'raw'): {
+    q: ArrayStorage;
+    r: ArrayStorage;
+} | ArrayStorage | {
+    h: ArrayStorage;
+    tau: ArrayStorage;
+};
+/**
+ * Cholesky decomposition.
+ *
+ * Returns the lower triangular matrix L such that A = L @ L^T
+ * for a symmetric positive-definite matrix A.
+ *
+ * @param a - Symmetric positive-definite matrix
+ * @param upper - If true, return upper triangular U such that A = U^T @ U
+ * @returns Lower (or upper) triangular Cholesky factor
+ */
+export declare function cholesky(a: ArrayStorage, upper?: boolean): ArrayStorage;
+/**
+ * Singular Value Decomposition.
+ *
+ * @param a - Input matrix (m x n)
+ * @param full_matrices - If true, return full U and V^T, otherwise reduced
+ * @param compute_uv - If true, return U, S, V^T; if false, return only S
+ * @returns { u, s, vt } or just s depending on compute_uv
+ */
+export declare function svd(a: ArrayStorage, full_matrices?: boolean, compute_uv?: boolean): {
+    u: ArrayStorage;
+    s: ArrayStorage;
+    vt: ArrayStorage;
+} | ArrayStorage;
+/**
+ * Compute the determinant of a square matrix.
+ *
+ * Uses LU decomposition for numerical stability.
+ *
+ * @param a - Square matrix
+ * @returns Determinant
+ */
+export declare function det(a: ArrayStorage): number;
+/**
+ * Compute the matrix inverse - optimized to do LU decomposition once.
+ *
+ * @param a - Square matrix
+ * @returns Inverse matrix
+ */
+export declare function inv(a: ArrayStorage): ArrayStorage;
+/**
+ * Solve a linear system A @ x = b.
+ *
+ * @param a - Coefficient matrix (n x n)
+ * @param b - Right-hand side (n,) or (n, k)
+ * @returns Solution x with same shape as b
+ */
+export declare function solve(a: ArrayStorage, b: ArrayStorage): ArrayStorage;
+/**
+ * Compute the least-squares solution to a linear matrix equation.
+ *
+ * @param a - Coefficient matrix (m x n)
+ * @param b - Right-hand side (m,) or (m, k)
+ * @param rcond - Cutoff for small singular values (default: machine precision * max(m, n))
+ * @returns { x, residuals, rank, s } - Solution, residuals, effective rank, singular values
+ */
+export declare function lstsq(a: ArrayStorage, b: ArrayStorage, rcond?: number | null): {
+    x: ArrayStorage;
+    residuals: ArrayStorage;
+    rank: number;
+    s: ArrayStorage;
+};
+/**
+ * Compute the condition number of a matrix.
+ *
+ * @param a - Input matrix
+ * @param p - Order of the norm (default: 2, -2, 'fro', or inf)
+ * @returns Condition number
+ */
+export declare function cond(a: ArrayStorage, p?: number | 'fro' | 'nuc'): number;
+/**
+ * Compute the rank of a matrix using SVD.
+ *
+ * @param a - Input matrix
+ * @param tol - Threshold below which singular values are considered zero
+ * @returns Matrix rank
+ */
+export declare function matrix_rank(a: ArrayStorage, tol?: number): number;
+/**
+ * Raise a square matrix to an integer power.
+ *
+ * @param a - Input square matrix
+ * @param n - Integer power (can be negative)
+ * @returns Matrix raised to power n
+ */
+export declare function matrix_power(a: ArrayStorage, n: number): ArrayStorage;
+/**
+ * Compute the Moore-Penrose pseudo-inverse using SVD.
+ *
+ * @param a - Input matrix
+ * @param rcond - Cutoff for small singular values
+ * @returns Pseudo-inverse of a
+ */
+export declare function pinv(a: ArrayStorage, rcond?: number): ArrayStorage;
+/**
+ * Compute eigenvalues and right eigenvectors of a square matrix.
+ *
+ * For general matrices, uses iterative methods.
+ * For symmetric matrices, use eigh for better performance.
+ *
+ * **Limitation**: Complex eigenvalues are not supported. For non-symmetric matrices,
+ * this function returns only the real parts of eigenvalues. If your matrix has
+ * complex eigenvalues (e.g., rotation matrices), results will be incorrect.
+ * Use eigh() for symmetric matrices where eigenvalues are guaranteed to be real.
+ *
+ * @param a - Input square matrix
+ * @returns { w, v } - Eigenvalues (real only) and eigenvector matrix
+ */
+export declare function eig(a: ArrayStorage): {
+    w: ArrayStorage;
+    v: ArrayStorage;
+};
+/**
+ * Compute eigenvalues and eigenvectors of a real symmetric matrix.
+ *
+ * Note: Named "Hermitian" for NumPy compatibility, but only real symmetric
+ * matrices are supported (complex Hermitian matrices require complex dtype support).
+ * Symmetric matrices always have real eigenvalues, so results are exact.
+ *
+ * @param a - Real symmetric matrix
+ * @param UPLO - 'L' or 'U' to use lower or upper triangle (default: 'L')
+ * @returns { w, v } - Eigenvalues (sorted ascending) and eigenvector matrix
+ */
+export declare function eigh(a: ArrayStorage, UPLO?: 'L' | 'U'): {
+    w: ArrayStorage;
+    v: ArrayStorage;
+};
+/**
+ * Compute eigenvalues of a general square matrix.
+ *
+ * **Limitation**: Complex eigenvalues are not supported. For non-symmetric matrices,
+ * this function returns only real approximations. Use eigvalsh() for symmetric
+ * matrices where eigenvalues are guaranteed to be real.
+ *
+ * @param a - Input square matrix
+ * @returns Array of eigenvalues (real only)
+ */
+export declare function eigvals(a: ArrayStorage): ArrayStorage;
+/**
+ * Compute eigenvalues of a real symmetric matrix.
+ *
+ * Note: Named "Hermitian" for NumPy compatibility, but only real symmetric
+ * matrices are supported (complex Hermitian matrices require complex dtype support).
+ * Symmetric matrices always have real eigenvalues, so results are exact.
+ *
+ * @param a - Real symmetric matrix
+ * @param UPLO - 'L' or 'U' to use lower or upper triangle
+ * @returns Array of eigenvalues (sorted ascending)
+ */
+export declare function eigvalsh(a: ArrayStorage, UPLO?: 'L' | 'U'): ArrayStorage;
 //# sourceMappingURL=linalg.d.ts.map