numpy-ts 0.7.0 → 0.9.0

package/dist/types/io/txt/parser.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Text file parsing for numpy-ts
+ *
+ * Provides NumPy-compatible loadtxt/genfromtxt functionality.
+ * These functions work with strings and are environment-agnostic.
+ */
+import { NDArray } from '../../core/ndarray';
+import type { DType } from '../../core/dtype';
+/**
+ * Options for parsing text data
+ */
+export interface ParseTxtOptions {
+    /**
+     * The string used to separate values.
+     * By default, any consecutive whitespace acts as delimiter.
+     * If specified, the exact delimiter is used.
+     */
+    delimiter?: string;
+    /**
+     * The character used to indicate the start of a comment.
+     * Lines beginning with this character (after stripping whitespace) will be skipped.
+     * Default: '#'
+     */
+    comments?: string;
+    /**
+     * Skip the first `skiprows` lines.
+     * Default: 0
+     */
+    skiprows?: number;
+    /**
+     * Which columns to read, with 0 being the first.
+     * If not specified, all columns are read.
+     */
+    usecols?: number | number[];
+    /**
+     * Read only the first `max_rows` lines of content after `skiprows`.
+     * Default: read all rows
+     */
+    max_rows?: number;
+    /**
+     * Data type of the resulting array.
+     * Default: 'float64'
+     */
+    dtype?: DType;
+    /**
+     * What encoding to use when reading the file.
+     * Only relevant for Node.js file operations.
+     * Default: 'utf-8'
+     */
+    encoding?: string;
+    /**
+     * The string representation of a missing value.
+     * Used by genfromtxt. When encountered, the value is replaced with `filling_values`.
+     */
+    missing_values?: string | string[];
+    /**
+     * The value to use for missing values.
+     * Default: NaN for floating point, 0 for integers
+     */
+    filling_values?: number;
+}
+/**
+ * Parse text data into an NDArray.
+ *
+ * This is the browser-compatible core function. For file operations in Node.js,
+ * use `loadtxt` from 'numpy-ts/node'.
+ *
+ * @param text - The text content to parse
+ * @param options - Parsing options
+ * @returns NDArray with the parsed data
+ *
+ * @example
+ * ```typescript
+ * const text = "1 2 3\n4 5 6\n7 8 9";
+ * const arr = parseTxt(text);
+ * // arr.shape = [3, 3]
+ * ```
+ */
+export declare function parseTxt(text: string, options?: ParseTxtOptions): NDArray;
+/**
+ * Parse text data into an NDArray with more flexible handling.
+ *
+ * Similar to parseTxt but handles missing values more gracefully.
+ * This is the browser-compatible version.
+ *
+ * @param text - The text content to parse
+ * @param options - Parsing options
+ * @returns NDArray with the parsed data
+ */
+export declare function genfromtxt(text: string, options?: ParseTxtOptions): NDArray;
+/**
+ * Parse text data using a regular expression.
+ *
+ * Extract data from each line using regex groups.
+ *
+ * @param text - The text content to parse
+ * @param regexp - Regular expression with groups to extract values
+ * @param dtype - Data type of the resulting array (default: 'float64')
+ * @returns NDArray with the parsed data
+ *
+ * @example
+ * ```typescript
+ * const text = "x=1.0, y=2.0\nx=3.0, y=4.0";
+ * const arr = fromregex(text, /x=([\d.]+), y=([\d.]+)/);
+ * // arr = [[1.0, 2.0], [3.0, 4.0]]
+ * ```
+ */
+export declare function fromregex(text: string, regexp: RegExp | string, dtype?: DType): NDArray;
+//# sourceMappingURL=parser.d.ts.map

package/dist/types/io/txt/serializer.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Text file serialization for numpy-ts
+ *
+ * Provides NumPy-compatible savetxt functionality.
+ * These functions work with strings and are environment-agnostic.
+ */
+import { NDArray } from '../../core/ndarray';
+/**
+ * Options for serializing array to text
+ */
+export interface SerializeTxtOptions {
+    /**
+     * Format string for a single value.
+     * Uses a simplified printf-style format:
+     * - '%.6f' - 6 decimal places (default for floats)
+     * - '%.2e' - scientific notation with 2 decimal places
+     * - '%d' - integer
+     * - '%s' - string representation
+     *
+     * Default: '%.18e' (NumPy default for full precision)
+     */
+    fmt?: string;
+    /**
+     * String or character separating columns.
+     * Default: ' ' (single space)
+     */
+    delimiter?: string;
+    /**
+     * String that will be written at the end of each row.
+     * Default: '\n'
+     */
+    newline?: string;
+    /**
+     * String that will be written at the beginning of the file.
+     * Will be prepended with the comment character if it doesn't start with one.
+     */
+    header?: string;
+    /**
+     * String that will be written at the end of the file.
+     */
+    footer?: string;
+    /**
+     * String that will be prepended to the header and footer strings,
+     * to mark them as comments.
+     * Default: '# '
+     */
+    comments?: string;
+}
+/**
+ * Serialize an NDArray to text format.
+ *
+ * This is the browser-compatible core function. For file operations in Node.js,
+ * use `savetxt` from 'numpy-ts/node'.
+ *
+ * @param arr - The array to serialize (must be 1D or 2D)
+ * @param options - Serialization options
+ * @returns String representation of the array
+ *
+ * @example
+ * ```typescript
+ * const arr = np.array([[1, 2, 3], [4, 5, 6]]);
+ * const text = serializeTxt(arr, { delimiter: ',' });
+ * // "1.000000000000000000e+00,2.000000000000000000e+00,3.000000000000000000e+00\n4.000000000000000000e+00,5.000000000000000000e+00,6.000000000000000000e+00\n"
+ * ```
+ */
+export declare function serializeTxt(arr: NDArray, options?: SerializeTxtOptions): string;
+//# sourceMappingURL=serializer.d.ts.map

package/dist/types/node.d.ts

@@ -15,6 +15,8 @@
 import { NDArray } from './core/ndarray';
 import { type NpzParseOptions, type NpzParseResult } from './io/npz/parser';
 import { type NpzSerializeOptions, type NpzArraysInput } from './io/npz/serializer';
+import { type ParseTxtOptions, type SerializeTxtOptions } from './io/txt';
+import type { DType } from './core/dtype';
 export * from './index';
 export * from './io';
 /**
@@ -151,4 +153,124 @@ export declare function savez(path: string, arrays: NpzArraysInput): Promise<voi
  * @param arrays - Arrays to save (same input types as savez)
  */
 export declare function savez_compressed(path: string, arrays: NpzArraysInput): Promise<void>;
+/**
+ * Options for loadtxt
+ */
+export interface LoadTxtOptions extends ParseTxtOptions {
+}
+/**
+ * Options for savetxt
+ */
+export interface SaveTxtOptions extends SerializeTxtOptions {
+}
+/**
+ * Load data from a text file.
+ *
+ * Each row in the text file must have the same number of values.
+ *
+ * @param path - Path to the text file
+ * @param options - Load options
+ * @returns NDArray with the loaded data
+ *
+ * @example
+ * ```typescript
+ * // Load a CSV file
+ * const arr = await loadtxt('data.csv', { delimiter: ',' });
+ *
+ * // Load with specific columns
+ * const arr = await loadtxt('data.txt', { usecols: [0, 2] });
+ *
+ * // Skip header rows
+ * const arr = await loadtxt('data.txt', { skiprows: 1 });
+ * ```
+ */
+export declare function loadtxt(path: string, options?: LoadTxtOptions): Promise<NDArray>;
+/**
+ * Synchronously load data from a text file.
+ *
+ * @param path - Path to the text file
+ * @param options - Load options
+ * @returns NDArray with the loaded data
+ */
+export declare function loadtxtSync(path: string, options?: LoadTxtOptions): NDArray;
+/**
+ * Save an array to a text file.
+ *
+ * @param path - Path to save the text file
+ * @param arr - The array to save (must be 1D or 2D)
+ * @param options - Save options
+ *
+ * @example
+ * ```typescript
+ * // Save as CSV
+ * await savetxt('data.csv', arr, { delimiter: ',' });
+ *
+ * // Save with custom format
+ * await savetxt('data.txt', arr, { fmt: '%.2f', delimiter: '\t' });
+ *
+ * // Save with header
+ * await savetxt('data.txt', arr, { header: 'x y z' });
+ * ```
+ */
+export declare function savetxt(path: string, arr: NDArray, options?: SaveTxtOptions): Promise<void>;
+/**
+ * Synchronously save an array to a text file.
+ *
+ * @param path - Path to save the text file
+ * @param arr - The array to save (must be 1D or 2D)
+ * @param options - Save options
+ */
+export declare function savetxtSync(path: string, arr: NDArray, options?: SaveTxtOptions): void;
+/**
+ * Load data from a text file with more flexible handling.
+ *
+ * Similar to loadtxt but handles missing values more gracefully.
+ *
+ * @param path - Path to the text file
+ * @param options - Load options
+ * @returns NDArray with the loaded data
+ *
+ * @example
+ * ```typescript
+ * // Load file with missing values
+ * const arr = await genfromtxt('data.csv', {
+ *   delimiter: ',',
+ *   missing_values: ['NA', ''],
+ *   filling_values: 0
+ * });
+ * ```
+ */
+export declare function genfromtxt(path: string, options?: LoadTxtOptions): Promise<NDArray>;
+/**
+ * Synchronously load data from a text file with more flexible handling.
+ *
+ * @param path - Path to the text file
+ * @param options - Load options
+ * @returns NDArray with the loaded data
+ */
+export declare function genfromtxtSync(path: string, options?: LoadTxtOptions): NDArray;
+/**
+ * Load data from a text file using regular expressions.
+ *
+ * @param path - Path to the text file
+ * @param regexp - Regular expression with capture groups for extracting values
+ * @param dtype - Data type of the resulting array (default: 'float64')
+ * @returns NDArray with the extracted data
+ *
+ * @example
+ * ```typescript
+ * // Extract x,y pairs from "Point: x=1.0, y=2.0" format
+ * const arr = await fromregex('points.txt', /x=([\d.]+), y=([\d.]+)/);
+ * ```
+ */
+export declare function fromregex(path: string, regexp: RegExp | string, dtype?: DType): Promise<NDArray>;
+/**
+ * Synchronously load data from a text file using regular expressions.
+ *
+ * @param path - Path to the text file
+ * @param regexp - Regular expression with capture groups for extracting values
+ * @param dtype - Data type of the resulting array (default: 'float64')
+ * @returns NDArray with the extracted data
+ */
+export declare function fromregexSync(path: string, regexp: RegExp | string, dtype?: DType): NDArray;
 //# sourceMappingURL=node.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