numpy-ts 0.11.0 → 0.13.0

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

@@ -0,0 +1,110 @@
+/**
+ * Arithmetic Functions - Tree-shakeable standalone functions
+ *
+ * This module provides arithmetic and mathematical functions that can be
+ * imported independently for optimal tree-shaking.
+ *
+ * Import from here for minimal bundle size:
+ *   import { sqrt, exp, abs } from 'numpy-ts/functions/arithmetic';
+ *
+ * Or import from main entry point (also tree-shakeable):
+ *   import { sqrt, exp, abs } from 'numpy-ts';
+ */
+import { NDArrayCore } from './types';
+/** Add arguments element-wise */
+export declare function add(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Subtract arguments element-wise */
+export declare function subtract(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Multiply arguments element-wise */
+export declare function multiply(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Square root of array elements */
+export declare function sqrt(x: NDArrayCore): NDArrayCore;
+/** Element-wise power */
+export declare function power(x: NDArrayCore, exponent: NDArrayCore | number): NDArrayCore;
+/** Alias for power */
+export declare const pow: typeof power;
+/** Exponential (e^x) */
+export declare function exp(x: NDArrayCore): NDArrayCore;
+/** 2^x */
+export declare function exp2(x: NDArrayCore): NDArrayCore;
+/** exp(x) - 1 */
+export declare function expm1(x: NDArrayCore): NDArrayCore;
+/** Natural logarithm */
+export declare function log(x: NDArrayCore): NDArrayCore;
+/** Base-2 logarithm */
+export declare function log2(x: NDArrayCore): NDArrayCore;
+/** Base-10 logarithm */
+export declare function log10(x: NDArrayCore): NDArrayCore;
+/** log(1 + x) */
+export declare function log1p(x: NDArrayCore): NDArrayCore;
+/** log(exp(x1) + exp(x2)) */
+export declare function logaddexp(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** log2(2^x1 + 2^x2) */
+export declare function logaddexp2(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Absolute value */
+export declare function absolute(x: NDArrayCore): NDArrayCore;
+/** Alias for absolute */
+export declare const abs: typeof absolute;
+/** Numerical negative */
+export declare function negative(x: NDArrayCore): NDArrayCore;
+/** Element-wise sign */
+export declare function sign(x: NDArrayCore): NDArrayCore;
+/** Element-wise modulo */
+export declare function mod(x: NDArrayCore, divisor: NDArrayCore | number): NDArrayCore;
+/** Element-wise division */
+export declare function divide(x: NDArrayCore, divisor: NDArrayCore | number): NDArrayCore;
+/** Alias for divide */
+export declare const true_divide: typeof divide;
+/** Element-wise floor division */
+export declare function floor_divide(x: NDArrayCore, divisor: NDArrayCore | number): NDArrayCore;
+/** Numerical positive (returns copy) */
+export declare function positive(x: NDArrayCore): NDArrayCore;
+/** Reciprocal (1/x) */
+export declare function reciprocal(x: NDArrayCore): NDArrayCore;
+/** Cube root */
+export declare function cbrt(x: NDArrayCore): NDArrayCore;
+/** Absolute value (float) */
+export declare function fabs(x: NDArrayCore): NDArrayCore;
+/** Element-wise divmod (quotient and remainder) */
+export declare function divmod(x: NDArrayCore, y: NDArrayCore | number): [NDArrayCore, NDArrayCore];
+/** Element-wise square */
+export declare function square(x: NDArrayCore): NDArrayCore;
+/** Element-wise remainder */
+export declare function remainder(x: NDArrayCore, y: NDArrayCore | number): NDArrayCore;
+/** Heaviside step function */
+export declare function heaviside(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Float power (always returns float) */
+export declare function float_power(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** C-style fmod */
+export declare function fmod(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Decompose into mantissa and exponent */
+export declare function frexp(x: NDArrayCore): [NDArrayCore, NDArrayCore];
+/** Greatest common divisor */
+export declare function gcd(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Least common multiple */
+export declare function lcm(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Compose from mantissa and exponent */
+export declare function ldexp(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Decompose into fractional and integer parts */
+export declare function modf(x: NDArrayCore): [NDArrayCore, NDArrayCore];
+/** Clip values to a range */
+export declare function clip(a: NDArrayCore, a_min: NDArrayCore | number | null, a_max: NDArrayCore | number | null): NDArrayCore;
+/** Element-wise maximum */
+export declare function maximum(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Element-wise minimum */
+export declare function minimum(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Element-wise maximum (ignores NaN) */
+export declare function fmax(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Element-wise minimum (ignores NaN) */
+export declare function fmin(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Replace NaN/Inf with numbers */
+export declare function nan_to_num(x: NDArrayCore, nan?: number, posinf?: number, neginf?: number): NDArrayCore;
+/** 1D linear interpolation */
+export declare function interp(x: NDArrayCore, xp: NDArrayCore, fp: NDArrayCore, left?: number, right?: number): NDArrayCore;
+/** Unwrap phase angles */
+export declare function unwrap(p: NDArrayCore, discont?: number, axis?: number, period?: number): NDArrayCore;
+/** Sinc function */
+export declare function sinc(x: NDArrayCore): NDArrayCore;
+/** Modified Bessel function of the first kind, order 0 */
+export declare function i0(x: NDArrayCore): NDArrayCore;
+//# sourceMappingURL=arithmetic.d.ts.map

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

@@ -0,0 +1,34 @@
+/**
+ * Bitwise Functions - Tree-shakeable standalone functions
+ *
+ * This module provides bitwise operations that can be
+ * imported independently for optimal tree-shaking.
+ */
+import { NDArrayCore } from './types';
+/** Bitwise AND */
+export declare function bitwise_and(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Bitwise OR */
+export declare function bitwise_or(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Bitwise XOR */
+export declare function bitwise_xor(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Bitwise NOT */
+export declare function bitwise_not(x: NDArrayCore): NDArrayCore;
+/** Bitwise inversion (alias for bitwise_not) */
+export declare function invert(x: NDArrayCore): NDArrayCore;
+/** Left shift */
+export declare function left_shift(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Right shift */
+export declare function right_shift(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Pack bits into bytes */
+export declare function packbits(a: NDArrayCore, axis?: number, bitorder?: 'big' | 'little'): NDArrayCore;
+/** Unpack bytes into bits */
+export declare function unpackbits(a: NDArrayCore, axis?: number, count?: number, bitorder?: 'big' | 'little'): NDArrayCore;
+/** Count number of 1 bits */
+export declare function bitwise_count(x: NDArrayCore): NDArrayCore;
+/** Alias for bitwise_not */
+export declare function bitwise_invert(x: NDArrayCore): NDArrayCore;
+/** Alias for left_shift */
+export declare function bitwise_left_shift(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Alias for right_shift */
+export declare function bitwise_right_shift(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+//# sourceMappingURL=bitwise.d.ts.map

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

@@ -1,94 +1,19 @@
 /**
- * Complex number class for numpy-ts
+ * Complex Number Functions - Tree-shakeable standalone functions
  *
- * Represents complex numbers in JavaScript, similar to Python's complex type.
- * Used when converting complex arrays to JavaScript values via toArray().
+ * This module provides complex number operations that can be
+ * imported independently for optimal tree-shaking.
  */
-/**
- * Represents a complex number with real and imaginary parts.
- *
- * @example
- * ```typescript
- * const z = new Complex(1, 2);  // 1 + 2i
- * console.log(z.re);  // 1
- * console.log(z.im);  // 2
- * console.log(z.toString());  // "(1+2j)"
- * ```
- */
-export declare class Complex {
-    /** Real part */
-    readonly re: number;
-    /** Imaginary part */
-    readonly im: number;
-    constructor(re: number, im?: number);
-    /**
-     * Returns the magnitude (absolute value) of the complex number.
-     * |z| = sqrt(re² + im²)
-     */
-    abs(): number;
-    /**
-     * Returns the phase angle (argument) of the complex number in radians.
-     * arg(z) = atan2(im, re)
-     */
-    angle(): number;
-    /**
-     * Returns the complex conjugate.
-     * conj(a + bi) = a - bi
-     */
-    conj(): Complex;
-    /**
-     * Add another complex number or real number.
-     */
-    add(other: Complex | number): Complex;
-    /**
-     * Subtract another complex number or real number.
-     */
-    sub(other: Complex | number): Complex;
-    /**
-     * Multiply by another complex number or real number.
-     * (a + bi)(c + di) = (ac - bd) + (ad + bc)i
-     */
-    mul(other: Complex | number): Complex;
-    /**
-     * Divide by another complex number or real number.
-     * (a + bi) / (c + di) = ((ac + bd) + (bc - ad)i) / (c² + d²)
-     */
-    div(other: Complex | number): Complex;
-    /**
-     * Returns the negation of this complex number.
-     */
-    neg(): Complex;
-    /**
-     * Check equality with another complex number.
-     */
-    equals(other: Complex): boolean;
-    /**
-     * String representation matching NumPy/Python format: "(a+bj)"
-     */
-    toString(): string;
-    /**
-     * Create a Complex from various input formats.
-     * Accepts:
-     * - Complex instance
-     * - {re, im} object
-     * - [re, im] array
-     * - number (creates re + 0i)
-     */
-    static from(value: ComplexInput): Complex;
-    /**
-     * Check if a value is a complex number representation.
-     */
-    static isComplex(value: unknown): value is ComplexInput;
-}
-/**
- * Input types that can be converted to Complex.
- */
-export type ComplexInput = Complex | {
-    re: number;
-    im?: number;
-} | [number, number] | number;
-/**
- * Helper to check if a value looks like a complex number input.
- */
-export declare function isComplexLike(value: unknown): value is ComplexInput;
+import { NDArrayCore } from './types';
+export { Complex } from '../common/complex';
+/** Extract real part of array */
+export declare function real(x: NDArrayCore): NDArrayCore;
+/** Extract imaginary part of array */
+export declare function imag(x: NDArrayCore): NDArrayCore;
+/** Complex conjugate */
+export declare function conj(x: NDArrayCore): NDArrayCore;
+/** Alias for conj */
+export declare const conjugate: typeof conj;
+/** Phase angle */
+export declare function angle(x: NDArrayCore, deg?: boolean): NDArrayCore;
 //# sourceMappingURL=complex.d.ts.map

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

@@ -0,0 +1,98 @@
+/**
+ * Array Creation Functions - Tree-shakeable standalone module
+ *
+ * This module provides all array creation functions including:
+ * - Basic: zeros, ones, empty, full, array, arange, linspace, etc.
+ * - Advanced: diag, tri, meshgrid, vander, etc.
+ *
+ * All functions return NDArrayCore for optimal tree-shaking.
+ */
+import { NDArrayCore, type DType } from '../common/ndarray-core';
+import { type TypedArray } from '../common/dtype';
+export type { DType, TypedArray } from '../common/dtype';
+/**
+ * Create array of zeros
+ */
+export declare function zeros(shape: number[], dtype?: DType): NDArrayCore;
+/**
+ * Create array of ones
+ */
+export declare function ones(shape: number[], dtype?: DType): NDArrayCore;
+/**
+ * Create an uninitialized array (zeros in JS)
+ */
+export declare function empty(shape: number[], dtype?: DType): NDArrayCore;
+/**
+ * Create array filled with a constant value
+ */
+export declare function full(shape: number[], fill_value: number | bigint | boolean, dtype?: DType): NDArrayCore;
+/**
+ * Create array from nested JavaScript arrays
+ */
+export declare function array(data: unknown, dtype?: DType): NDArrayCore;
+/**
+ * Create array with evenly spaced values within a given interval
+ */
+export declare function arange(start: number, stop?: number, step?: number, dtype?: DType): NDArrayCore;
+/**
+ * Create array with evenly spaced values over a specified interval
+ */
+export declare function linspace(start: number, stop: number, num?: number, dtype?: DType): NDArrayCore;
+/**
+ * Create array with logarithmically spaced values
+ */
+export declare function logspace(start: number, stop: number, num?: number, base?: number, dtype?: DType): NDArrayCore;
+/**
+ * Create array with geometrically spaced values
+ */
+export declare function geomspace(start: number, stop: number, num?: number, dtype?: DType): NDArrayCore;
+/**
+ * Create identity matrix
+ */
+export declare function eye(n: number, m?: number, k?: number, dtype?: DType): NDArrayCore;
+/**
+ * Create a square identity matrix
+ */
+export declare function identity(n: number, dtype?: DType): NDArrayCore;
+/**
+ * Convert input to an ndarray
+ */
+export declare function asarray(a: NDArrayCore | unknown, dtype?: DType): NDArrayCore;
+/**
+ * Return array of zeros with the same shape and dtype as input
+ */
+export declare function zeros_like(a: NDArrayCore, dtype?: DType): NDArrayCore;
+/**
+ * Return array of ones with the same shape and dtype as input
+ */
+export declare function ones_like(a: NDArrayCore, dtype?: DType): NDArrayCore;
+/**
+ * Return empty array with the same shape and dtype as input
+ */
+export declare function empty_like(a: NDArrayCore, dtype?: DType): NDArrayCore;
+/**
+ * Return array filled with value, same shape and dtype as input
+ */
+export declare function full_like(a: NDArrayCore, fill_value: number | bigint | boolean, dtype?: DType): NDArrayCore;
+/**
+ * Deep copy of array
+ */
+export declare function copy(a: NDArrayCore): NDArrayCore;
+export declare function asanyarray(a: NDArrayCore | unknown, dtype?: DType): NDArrayCore;
+export declare function ascontiguousarray(a: NDArrayCore | unknown, dtype?: DType): NDArrayCore;
+export declare function asfortranarray(a: NDArrayCore | unknown, dtype?: DType): NDArrayCore;
+export declare function asarray_chkfinite(a: NDArrayCore | unknown, dtype?: DType): NDArrayCore;
+export declare function require(a: NDArrayCore, dtype?: DType, _requirements?: string | string[]): NDArrayCore;
+export declare function diag(v: NDArrayCore, k?: number): NDArrayCore;
+export declare function diagflat(v: NDArrayCore, k?: number): NDArrayCore;
+export declare function tri(N: number, M?: number, k?: number, dtype?: DType): NDArrayCore;
+export declare function tril(m: NDArrayCore, k?: number): NDArrayCore;
+export declare function triu(m: NDArrayCore, k?: number): NDArrayCore;
+export declare function vander(x: NDArrayCore, N?: number, increasing?: boolean): NDArrayCore;
+export declare function frombuffer(buffer: ArrayBuffer | TypedArray, dtype?: DType, count?: number, offset?: number): NDArrayCore;
+export declare function fromfunction(func: (...indices: number[]) => number, shape: number[], dtype?: DType): NDArrayCore;
+export declare function fromiter(iter: Iterable<number>, dtype?: DType, count?: number): NDArrayCore;
+export declare function fromstring(string: string, dtype?: DType, count?: number, sep?: string): NDArrayCore;
+export declare function fromfile(_file: string, _dtype?: DType, _count?: number, _sep?: string): NDArrayCore;
+export declare function meshgrid(...arrays: NDArrayCore[]): NDArrayCore[];
+//# sourceMappingURL=creation.d.ts.map

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

@@ -0,0 +1,29 @@
+/**
+ * Formatting and printing functions
+ *
+ * Tree-shakeable standalone functions that wrap the underlying ops.
+ */
+import { NDArrayCore } from '../common/ndarray-core';
+import * as formattingOps from '../common/ops/formatting';
+export declare const set_printoptions: typeof formattingOps.set_printoptions;
+export declare const get_printoptions: typeof formattingOps.get_printoptions;
+export declare const printoptions: typeof formattingOps.printoptions;
+export declare const format_float_positional: typeof formattingOps.format_float_positional;
+export declare const format_float_scientific: typeof formattingOps.format_float_scientific;
+export declare const base_repr: typeof formattingOps.base_repr;
+export declare const binary_repr: typeof formattingOps.binary_repr;
+export declare function array2string(a: NDArrayCore, options?: {
+    max_line_width?: number;
+    precision?: number;
+    suppress_small?: boolean;
+    separator?: string;
+    prefix?: string;
+    suffix?: string;
+    threshold?: number;
+    edgeitems?: number;
+    sign?: ' ' | '+' | '-';
+    floatmode?: 'fixed' | 'unique' | 'maxprec' | 'maxprec_equal';
+}): string;
+export declare function array_repr(a: NDArrayCore, max_line_width?: number, precision?: number, suppress_small?: boolean): string;
+export declare function array_str(a: NDArrayCore, max_line_width?: number, precision?: number): string;
+//# sourceMappingURL=formatting.d.ts.map

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

@@ -0,0 +1,14 @@
+/**
+ * Gradient and Differentiation Functions - Tree-shakeable standalone functions
+ *
+ * This module provides differentiation operations that can be
+ * imported independently for optimal tree-shaking.
+ */
+import { NDArrayCore } from './types';
+/** Calculate n-th discrete difference */
+export declare function diff(a: NDArrayCore, n?: number, axis?: number): NDArrayCore;
+/** Difference between consecutive elements in 1D array */
+export declare function ediff1d(a: NDArrayCore, to_end?: number[] | null, to_begin?: number[] | null): NDArrayCore;
+/** Return gradient of N-dimensional array */
+export declare function gradient(f: NDArrayCore, varargs?: number | number[], axis?: number | number[] | null): NDArrayCore | NDArrayCore[];
+//# sourceMappingURL=gradient.d.ts.map

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

@@ -0,0 +1,40 @@
+/**
+ * Core Module - Tree-shakeable standalone functions
+ *
+ * This module re-exports all standalone functions from the various
+ * function modules. All functions return NDArrayCore for optimal tree-shaking.
+ *
+ * For optimal tree-shaking, you can also import from specific submodules:
+ *   import { sin, cos } from 'numpy-ts/core/trig';
+ *   import { dot, inv } from 'numpy-ts/core/linalg';
+ */
+export type { DType, TypedArray } from './types';
+export { NDArrayCore, Complex, ArrayStorage } from './types';
+export { zeros, ones, empty, full, array, arange, linspace, logspace, geomspace, eye, identity, asarray, zeros_like, ones_like, empty_like, full_like, copy, asanyarray, ascontiguousarray, asfortranarray, asarray_chkfinite, require, diag, diagflat, tri, tril, triu, vander, frombuffer, fromfunction, fromiter, fromstring, fromfile, meshgrid, } from './creation';
+export { add, subtract, multiply, sqrt, power, pow, exp, exp2, expm1, log, log2, log10, log1p, logaddexp, logaddexp2, absolute, abs, negative, sign, mod, divide, true_divide, 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, } from './arithmetic';
+export { sin, cos, tan, arcsin, asin, arccos, acos, arctan, atan, arctan2, atan2, hypot, degrees, radians, deg2rad, rad2deg, sinh, cosh, tanh, arcsinh, asinh, arccosh, acosh, arctanh, atanh, } from './trig';
+export { dot, matmul, trace, diagonal, kron, transpose, inner, outer, tensordot, einsum, einsum_path, vdot, vecdot, matrix_transpose, permute_dims, matvec, vecmat, cross, linalg, } from './linalg';
+export { reshape, flatten, ravel, squeeze, expand_dims, swapaxes, moveaxis, rollaxis, concatenate, stack, vstack, hstack, dstack, concat, column_stack, row_stack, block, split, array_split, vsplit, hsplit, dsplit, unstack, tile, repeat, flip, fliplr, flipud, rot90, roll, resize, atleast_1d, atleast_2d, atleast_3d, } from './shape';
+export { sum, mean, prod, max, amax, min, amin, ptp, argmin, argmax, variance, var_, variance as var, std, median, percentile, quantile, average, all, any, cumsum, cumulative_sum, cumprod, cumulative_prod, nansum, nanprod, nanmean, nanvar, nanstd, nanmin, nanmax, nanargmin, nanargmax, nancumsum, nancumprod, nanmedian, nanquantile, nanpercentile, } from './reduction';
+export { logical_and, logical_or, logical_not, logical_xor, isfinite, isinf, isnan, isnat, isneginf, isposinf, iscomplex, iscomplexobj, isreal, isrealobj, real_if_close, isfortran, isscalar, iterable, isdtype, promote_types, copysign, signbit, nextafter, spacing, greater, greater_equal, less, less_equal, equal, not_equal, isclose, allclose, } from './logic';
+export { sort, argsort, lexsort, partition, argpartition, sort_complex, nonzero, argwhere, flatnonzero, where, searchsorted, extract, count_nonzero, } from './sorting';
+export { 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, } from './bitwise';
+export { around, round_, round, ceil, fix, floor, rint, trunc } from './rounding';
+export { unique, in1d, intersect1d, isin, setdiff1d, setxor1d, union1d, trim_zeros, unique_all, unique_counts, unique_inverse, unique_values, } from './sets';
+export { bincount, digitize, histogram, histogram2d, histogramdd, correlate, convolve, cov, corrcoef, histogram_bin_edges, trapezoid, } from './statistics';
+export { diff, ediff1d, gradient } from './gradient';
+export { real, imag, conj, conjugate, angle } from './complex';
+export { broadcast_to, broadcast_arrays, broadcast_shapes, take, put, take_along_axis, put_along_axis, choose, compress, select, place, putmask, copyto, indices, ix_, ravel_multi_index, unravel_index, diag_indices, diag_indices_from, fill_diagonal, tril_indices, tril_indices_from, triu_indices, triu_indices_from, mask_indices, array_equal, array_equiv, apply_along_axis, apply_over_axes, may_share_memory, shares_memory, geterr, seterr, iindex, bindex, } from './advanced';
+export { set_printoptions, get_printoptions, printoptions, format_float_positional, format_float_scientific, base_repr, binary_repr, array2string, array_repr, array_str, } from './formatting';
+export { ndim, shape, size, item, tolist, tobytes, byteswap, view, tofile, fill } from './utility';
+export { append, delete_, delete_ as delete, insert, pad } from './shape-extra';
+export { can_cast, common_type, result_type, min_scalar_type, issubdtype, typename, mintypecode, } from './typechecking';
+export { poly, polyadd, polyder, polydiv, polyfit, polyint, polymul, polysub, polyval, roots, } from './polynomial';
+export { parseNpy, parseNpyHeader, parseNpyData } from '../io/npy/parser';
+export { serializeNpy } from '../io/npy/serializer';
+export { UnsupportedDTypeError, InvalidNpyError, SUPPORTED_DTYPES, DTYPE_TO_DESCR, type NpyHeader, type NpyMetadata, type NpyVersion, } from '../io/npy/format';
+export { parseNpz, parseNpzSync, loadNpz, loadNpzSync, type NpzParseOptions, type NpzParseResult, } from '../io/npz/parser';
+export { serializeNpz, serializeNpzSync, type NpzArraysInput, type NpzSerializeOptions, } from '../io/npz/serializer';
+export { parseTxt, genfromtxt, fromregex, type ParseTxtOptions } from '../io/txt/parser';
+export { serializeTxt, type SerializeTxtOptions } from '../io/txt/serializer';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,141 @@
+/**
+ * Linear Algebra Functions - Tree-shakeable standalone functions
+ *
+ * This module provides linear algebra functions that can be
+ * imported independently for optimal tree-shaking.
+ */
+import { NDArrayCore, Complex } from './types';
+/** Dot product of two arrays */
+export declare function dot(a: NDArrayCore, b: NDArrayCore): NDArrayCore | number | bigint | Complex;
+/** Matrix trace (sum of diagonal elements) */
+export declare function trace(a: NDArrayCore): number | bigint | Complex;
+/** Return diagonal or construct diagonal array */
+export declare function diagonal(a: NDArrayCore, offset?: number, axis1?: number, axis2?: number): NDArrayCore;
+/** Kronecker product */
+export declare function kron(a: NDArrayCore, b: NDArrayCore): NDArrayCore;
+/** Transpose array - returns a view */
+export declare function transpose(a: NDArrayCore, axes?: number[]): NDArrayCore;
+/** Inner product of two arrays */
+export declare function inner(a: NDArrayCore, b: NDArrayCore): NDArrayCore | number | bigint | Complex;
+/** Outer product of two arrays */
+export declare function outer(a: NDArrayCore, b: NDArrayCore): NDArrayCore;
+/** Tensor dot product */
+export declare function tensordot(a: NDArrayCore, b: NDArrayCore, axes?: number | [number[], number[]]): NDArrayCore | number | bigint | Complex;
+/** Evaluates Einstein summation convention */
+export declare function einsum(subscripts: string, ...operands: NDArrayCore[]): NDArrayCore | number | bigint | Complex;
+/** Compute the optimal contraction path for einsum */
+export declare function einsum_path(subscripts: string, ...operands: NDArrayCore[]): [([number, number] | number[])[], string];
+/** Vector dot product */
+export declare function vdot(a: NDArrayCore, b: NDArrayCore): number | bigint | Complex;
+/** Vector dot product along specified axis */
+export declare function vecdot(x1: NDArrayCore, x2: NDArrayCore, axis?: number): NDArrayCore | number | bigint | Complex;
+/** Matrix transpose (swap last two axes) */
+/** Matrix transpose - returns a view */
+export declare function matrix_transpose(a: NDArrayCore): NDArrayCore;
+/** Permute array dimensions - returns a view */
+export declare function permute_dims(a: NDArrayCore, axes?: number[]): NDArrayCore;
+/** Matrix-vector product */
+export declare function matvec(x1: NDArrayCore, x2: NDArrayCore): NDArrayCore;
+/** Vector-matrix product */
+export declare function vecmat(x1: NDArrayCore, x2: NDArrayCore): NDArrayCore;
+/** Cross product */
+export declare function cross(a: NDArrayCore, b: NDArrayCore, axisa?: number, axisb?: number, axisc?: number, axis?: number): NDArrayCore | number | Complex;
+/** Matrix multiplication */
+export declare function matmul(a: NDArrayCore, b: NDArrayCore): NDArrayCore;
+export declare const linalg: {
+    /** Matrix multiplication */
+    matmul: (a: NDArrayCore, b: NDArrayCore) => NDArrayCore;
+    /** Dot product */
+    dot: (a: NDArrayCore, b: NDArrayCore) => NDArrayCore | number | bigint | Complex;
+    /** Matrix determinant */
+    det: (a: NDArrayCore) => number;
+    /** Matrix inverse */
+    inv: (a: NDArrayCore) => NDArrayCore;
+    /** Solve linear system Ax = b */
+    solve: (a: NDArrayCore, b: NDArrayCore) => NDArrayCore;
+    /** Least-squares solution */
+    lstsq: (a: NDArrayCore, b: NDArrayCore, rcond?: number | null) => {
+        x: NDArrayCore;
+        residuals: NDArrayCore;
+        rank: number;
+        s: NDArrayCore;
+    };
+    /** Matrix or vector norm */
+    norm: (x: NDArrayCore, ord?: number | "fro" | "nuc" | null, axis?: number | [number, number] | null, keepdims?: boolean) => NDArrayCore | number;
+    /** Condition number */
+    cond: (a: NDArrayCore, p?: number | "fro" | "nuc") => number;
+    /** Matrix rank */
+    matrix_rank: (a: NDArrayCore, tol?: number) => number;
+    /** Raise matrix to a power */
+    matrix_power: (a: NDArrayCore, n: number) => NDArrayCore;
+    /** Pseudo-inverse */
+    pinv: (a: NDArrayCore, rcond?: number) => NDArrayCore;
+    /** QR decomposition */
+    qr: (a: NDArrayCore, mode?: "reduced" | "complete" | "r" | "raw") => {
+        q: NDArrayCore;
+        r: NDArrayCore;
+    } | NDArrayCore | {
+        h: NDArrayCore;
+        tau: NDArrayCore;
+    };
+    /** Cholesky decomposition */
+    cholesky: (a: NDArrayCore, upper?: boolean) => NDArrayCore;
+    /** Singular value decomposition */
+    svd: (a: NDArrayCore, full_matrices?: boolean, compute_uv?: boolean) => {
+        u: NDArrayCore;
+        s: NDArrayCore;
+        vt: NDArrayCore;
+    } | NDArrayCore;
+    /** Eigenvalues and eigenvectors */
+    eig: (a: NDArrayCore) => {
+        w: NDArrayCore;
+        v: NDArrayCore;
+    };
+    /** Eigenvalues and eigenvectors of Hermitian matrix */
+    eigh: (a: NDArrayCore, UPLO?: "L" | "U") => {
+        w: NDArrayCore;
+        v: NDArrayCore;
+    };
+    /** Eigenvalues */
+    eigvals: (a: NDArrayCore) => NDArrayCore;
+    /** Eigenvalues of Hermitian matrix */
+    eigvalsh: (a: NDArrayCore, UPLO?: "L" | "U") => NDArrayCore;
+    /** Sign and log of determinant */
+    slogdet: (a: NDArrayCore) => {
+        sign: number;
+        logabsdet: number;
+    };
+    /** Singular values */
+    svdvals: (a: NDArrayCore) => NDArrayCore;
+    /** Chained dot product */
+    multi_dot: (arrays: NDArrayCore[]) => NDArrayCore;
+    /** Inverse of tensorization */
+    tensorinv: (a: NDArrayCore, ind?: number) => NDArrayCore;
+    /** Tensor equation solution */
+    tensorsolve: (a: NDArrayCore, b: NDArrayCore, axes?: number[]) => NDArrayCore;
+    /** Vector norm */
+    vector_norm: (x: NDArrayCore, ord?: number | "fro" | "nuc", axis?: number | null, keepdims?: boolean) => NDArrayCore | number;
+    /** Matrix norm */
+    matrix_norm: (x: NDArrayCore, ord?: number | "fro" | "nuc", keepdims?: boolean) => NDArrayCore | number;
+    /** Cross product */
+    cross: (a: NDArrayCore, b: NDArrayCore, axisa?: number, axisb?: number, axisc?: number, axis?: number) => NDArrayCore | number | Complex;
+    /** Matrix transpose (transposes last two axes) - returns a view */
+    matrix_transpose: (a: NDArrayCore) => NDArrayCore;
+    /** Permute array dimensions - returns a view */
+    permute_dims: (a: NDArrayCore, axes?: number[]) => NDArrayCore;
+    /** Matrix trace (sum of diagonal elements) */
+    trace: (a: NDArrayCore) => number | bigint | Complex;
+    /** Extract diagonal */
+    diagonal: (a: NDArrayCore, offset?: number, axis1?: number, axis2?: number) => NDArrayCore;
+    /** Outer product */
+    outer: (a: NDArrayCore, b: NDArrayCore) => NDArrayCore;
+    /** Inner product */
+    inner: (a: NDArrayCore, b: NDArrayCore) => NDArrayCore | number | bigint | Complex;
+    /** Tensor dot product */
+    tensordot: (a: NDArrayCore, b: NDArrayCore, axes?: number | [number[], number[]]) => NDArrayCore | number | bigint | Complex;
+    /** Vector dot product */
+    vecdot: (a: NDArrayCore, b: NDArrayCore, axis?: number) => NDArrayCore | number | bigint | Complex;
+    /** Transpose array - returns a view */
+    transpose: (a: NDArrayCore, axes?: number[]) => NDArrayCore;
+};
+//# sourceMappingURL=linalg.d.ts.map

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

@@ -0,0 +1,72 @@
+/**
+ * Logic Functions - Tree-shakeable standalone functions
+ *
+ * This module provides logical and type-checking functions that can be
+ * imported independently for optimal tree-shaking.
+ */
+import { NDArrayCore, type DType } from './types';
+/** Element-wise logical AND */
+export declare function logical_and(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Element-wise logical OR */
+export declare function logical_or(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Element-wise logical NOT */
+export declare function logical_not(x: NDArrayCore): NDArrayCore;
+/** Element-wise logical XOR */
+export declare function logical_xor(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Test for finite values */
+export declare function isfinite(x: NDArrayCore): NDArrayCore;
+/** Test for infinity */
+export declare function isinf(x: NDArrayCore): NDArrayCore;
+/** Test for NaN */
+export declare function isnan(x: NDArrayCore): NDArrayCore;
+/** Test for NaT (not a time) - returns all False for numeric arrays */
+export declare function isnat(x: NDArrayCore): NDArrayCore;
+/** Test for negative infinity */
+export declare function isneginf(x: NDArrayCore): NDArrayCore;
+/** Test for positive infinity */
+export declare function isposinf(x: NDArrayCore): NDArrayCore;
+/** Element-wise test for complex values */
+export declare function iscomplex(x: NDArrayCore): NDArrayCore;
+/** Check if array has complex dtype */
+export declare function iscomplexobj(x: NDArrayCore): boolean;
+/** Element-wise test for real values */
+export declare function isreal(x: NDArrayCore): NDArrayCore;
+/** Check if array has real dtype */
+export declare function isrealobj(x: NDArrayCore): boolean;
+/** Return real array if imaginary part is negligible */
+export declare function real_if_close(x: NDArrayCore, tol?: number): NDArrayCore;
+/** Check if array is Fortran contiguous */
+export declare function isfortran(x: NDArrayCore): boolean;
+/** Check if value is a scalar */
+export declare function isscalar(val: unknown): boolean;
+/** Check if object is iterable */
+export declare function iterable(obj: unknown): boolean;
+/** Check dtype against a kind string */
+export declare function isdtype(dtype: DType, kind: string): boolean;
+/** Promote dtypes to a common type */
+export declare function promote_types(dtype1: DType, dtype2: DType): DType;
+/** Return sign of x1 with magnitude of x2 */
+export declare function copysign(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Test for negative sign bit */
+export declare function signbit(x: NDArrayCore): NDArrayCore;
+/** Next floating-point value toward x2 */
+export declare function nextafter(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Spacing between x and nearest adjacent number */
+export declare function spacing(x: NDArrayCore): NDArrayCore;
+/** Element-wise greater than comparison */
+export declare function greater(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Element-wise greater than or equal comparison */
+export declare function greater_equal(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Element-wise less than comparison */
+export declare function less(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Element-wise less than or equal comparison */
+export declare function less_equal(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Element-wise equality comparison */
+export declare function equal(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Element-wise inequality comparison */
+export declare function not_equal(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Element-wise close comparison with tolerance */
+export declare function isclose(a: NDArrayCore, b: NDArrayCore | number, rtol?: number, atol?: number): NDArrayCore;
+/** Check if all elements are close */
+export declare function allclose(a: NDArrayCore, b: NDArrayCore | number, rtol?: number, atol?: number): boolean;
+//# sourceMappingURL=logic.d.ts.map