numpy-ts 0.6.0 → 0.8.0

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

@@ -284,6 +284,46 @@ export declare class NDArray {
      * @returns Boolean array (represented as uint8: 1=true, 0=false)
      */
     allclose(other: NDArray | number, rtol?: number, atol?: number): boolean;
+    /**
+     * Bitwise AND element-wise
+     * @param other - Array or scalar for AND operation (must be integer type)
+     * @returns Result of bitwise AND
+     */
+    bitwise_and(other: NDArray | number): NDArray;
+    /**
+     * Bitwise OR element-wise
+     * @param other - Array or scalar for OR operation (must be integer type)
+     * @returns Result of bitwise OR
+     */
+    bitwise_or(other: NDArray | number): NDArray;
+    /**
+     * Bitwise XOR element-wise
+     * @param other - Array or scalar for XOR operation (must be integer type)
+     * @returns Result of bitwise XOR
+     */
+    bitwise_xor(other: NDArray | number): NDArray;
+    /**
+     * Bitwise NOT (inversion) element-wise
+     * @returns Result of bitwise NOT
+     */
+    bitwise_not(): NDArray;
+    /**
+     * Invert (bitwise NOT) element-wise - alias for bitwise_not
+     * @returns Result of bitwise inversion
+     */
+    invert(): NDArray;
+    /**
+     * Left shift elements by positions
+     * @param shift - Shift amount (array or scalar)
+     * @returns Result of left shift
+     */
+    left_shift(shift: NDArray | number): NDArray;
+    /**
+     * Right shift elements by positions
+     * @param shift - Shift amount (array or scalar)
+     * @returns Result of right shift
+     */
+    right_shift(shift: NDArray | number): NDArray;
     /**
      * Sum array elements over a given axis
      * @param axis - Axis along which to sum. If undefined, sum all elements
@@ -494,6 +534,44 @@ export declare class NDArray {
      * @returns Median of array elements ignoring NaNs
      */
     nanmedian(axis?: number, keepdims?: boolean): NDArray | number;
+    /**
+     * Return a sorted copy of the array
+     * @param axis - Axis along which to sort. Default is -1 (last axis)
+     * @returns Sorted array
+     */
+    sort(axis?: number): NDArray;
+    /**
+     * Returns the indices that would sort this array
+     * @param axis - Axis along which to sort. Default is -1 (last axis)
+     * @returns Array of indices that sort the array
+     */
+    argsort(axis?: number): NDArray;
+    /**
+     * Partially sort the array
+     * @param kth - Element index to partition by
+     * @param axis - Axis along which to sort. Default is -1 (last axis)
+     * @returns Partitioned array
+     */
+    partition(kth: number, axis?: number): NDArray;
+    /**
+     * Returns indices that would partition the array
+     * @param kth - Element index to partition by
+     * @param axis - Axis along which to sort. Default is -1 (last axis)
+     * @returns Array of indices
+     */
+    argpartition(kth: number, axis?: number): NDArray;
+    /**
+     * Return the indices of non-zero elements
+     * @returns Tuple of arrays, one for each dimension
+     */
+    nonzero(): NDArray[];
+    /**
+     * Find indices where elements should be inserted to maintain order
+     * @param v - Values to insert
+     * @param side - 'left' or 'right' side to insert
+     * @returns Indices where values should be inserted
+     */
+    searchsorted(v: NDArray, side?: 'left' | 'right'): NDArray;
     /**
      * Reshape array to a new shape
      * Returns a new array with the specified shape
@@ -1726,6 +1804,84 @@ export declare function remainder(x: NDArray, y: NDArray | number): NDArray;
  * @returns Array with heaviside values (0 if x1 < 0, x2 if x1 == 0, 1 if x1 > 0)
  */
 export declare function heaviside(x1: NDArray, x2: NDArray | number): NDArray;
+/**
+ * Bitwise AND element-wise
+ *
+ * @param x1 - First input array (must be integer type)
+ * @param x2 - Second input array or scalar (must be integer type)
+ * @returns Result of bitwise AND
+ */
+export declare function bitwise_and(x1: NDArray, x2: NDArray | number): NDArray;
+/**
+ * Bitwise OR element-wise
+ *
+ * @param x1 - First input array (must be integer type)
+ * @param x2 - Second input array or scalar (must be integer type)
+ * @returns Result of bitwise OR
+ */
+export declare function bitwise_or(x1: NDArray, x2: NDArray | number): NDArray;
+/**
+ * Bitwise XOR element-wise
+ *
+ * @param x1 - First input array (must be integer type)
+ * @param x2 - Second input array or scalar (must be integer type)
+ * @returns Result of bitwise XOR
+ */
+export declare function bitwise_xor(x1: NDArray, x2: NDArray | number): NDArray;
+/**
+ * Bitwise NOT (inversion) element-wise
+ *
+ * @param x - Input array (must be integer type)
+ * @returns Result of bitwise NOT
+ */
+export declare function bitwise_not(x: NDArray): NDArray;
+/**
+ * Invert (bitwise NOT) element-wise
+ * Alias for bitwise_not
+ *
+ * @param x - Input array (must be integer type)
+ * @returns Result of bitwise inversion
+ */
+export declare function invert(x: NDArray): NDArray;
+/**
+ * Left shift elements by positions
+ *
+ * @param x1 - Input array (must be integer type)
+ * @param x2 - Shift amount (array or scalar)
+ * @returns Result of left shift
+ */
+export declare function left_shift(x1: NDArray, x2: NDArray | number): NDArray;
+/**
+ * Right shift elements by positions
+ *
+ * @param x1 - Input array (must be integer type)
+ * @param x2 - Shift amount (array or scalar)
+ * @returns Result of right shift
+ */
+export declare function right_shift(x1: NDArray, x2: NDArray | number): NDArray;
+/**
+ * Pack binary values into uint8 array
+ *
+ * Packs the elements of a binary-valued array into bits in a uint8 array.
+ *
+ * @param a - Input array (values are interpreted as binary: 0 or non-zero)
+ * @param axis - The dimension over which bit-packing is done (default: -1)
+ * @param bitorder - Order of bits: 'big' or 'little' (default: 'big')
+ * @returns Packed uint8 array
+ */
+export declare function packbits(a: NDArray, axis?: number, bitorder?: 'big' | 'little'): NDArray;
+/**
+ * Unpack uint8 array into binary values
+ *
+ * Unpacks elements of a uint8 array into a binary-valued output array.
+ *
+ * @param a - Input uint8 array
+ * @param axis - The dimension over which bit-unpacking is done (default: -1)
+ * @param count - Number of elements to unpack, or -1 for all (default: -1)
+ * @param bitorder - Order of bits: 'big' or 'little' (default: 'big')
+ * @returns Unpacked uint8 array of 0s and 1s
+ */
+export declare function unpackbits(a: NDArray, axis?: number, count?: number, bitorder?: 'big' | 'little'): NDArray;
 /**
  * Einstein summation convention
  *
@@ -1748,4 +1904,235 @@ export declare function heaviside(x1: NDArray, x2: NDArray | number): NDArray;
  * einsum('ii->', a)
  */
 export declare function einsum(subscripts: string, ...operands: NDArray[]): NDArray | number | bigint;
+/**
+ * Take values from the input array by matching 1d index and data slices along axis.
+ *
+ * @param arr - Input array
+ * @param indices - Index array with same ndim as arr
+ * @param axis - The axis along which to select values
+ * @returns Array of values taken along the axis
+ */
+export declare function take_along_axis(arr: NDArray, indices: NDArray, axis: number): NDArray;
+/**
+ * Put values into the destination array using 1d index and data slices along axis.
+ *
+ * @param arr - Destination array (modified in-place)
+ * @param indices - Index array with same ndim as arr
+ * @param values - Values to put
+ * @param axis - The axis along which to put values
+ */
+export declare function put_along_axis(arr: NDArray, indices: NDArray, values: NDArray, axis: number): void;
+/**
+ * Change elements of array based on conditional mask.
+ *
+ * @param a - Array to modify (in-place)
+ * @param mask - Boolean mask array
+ * @param values - Values to put where mask is True
+ */
+export declare function putmask(a: NDArray, mask: NDArray, values: NDArray | number | bigint): void;
+/**
+ * Return selected slices of array along given axis.
+ *
+ * @param condition - Boolean array for selecting
+ * @param a - Array from which to select
+ * @param axis - Axis along which to select (if undefined, works on flattened array)
+ * @returns Compressed array
+ */
+export declare function compress(condition: NDArray, a: NDArray, axis?: number): NDArray;
+/**
+ * Return an array drawn from elements in choicelist, depending on conditions.
+ *
+ * @param condlist - List of boolean arrays (conditions)
+ * @param choicelist - List of arrays to choose from
+ * @param defaultVal - Default value when no condition is met (default 0)
+ * @returns Array with selected values
+ */
+export declare function select(condlist: NDArray[], choicelist: NDArray[], defaultVal?: number | bigint): NDArray;
+/**
+ * Change elements of an array based on conditional and input values.
+ *
+ * @param arr - Array to modify (in-place)
+ * @param mask - Boolean mask array
+ * @param vals - Values to place where mask is True (cycles if shorter)
+ */
+export declare function place(arr: NDArray, mask: NDArray, vals: NDArray): void;
+/**
+ * Return the indices to access the main diagonal of an array.
+ *
+ * @param n - Size of arrays for which indices are returned
+ * @param ndim - Number of dimensions (default 2)
+ * @returns Tuple of index arrays
+ */
+export declare function diag_indices(n: number, ndim?: number): NDArray[];
+/**
+ * Return the indices to access the main diagonal of an n-dimensional array.
+ *
+ * @param arr - Input array (must have all equal dimensions)
+ * @returns Tuple of index arrays
+ */
+export declare function diag_indices_from(arr: NDArray): NDArray[];
+/**
+ * Return the indices for the lower-triangle of an (n, m) array.
+ *
+ * @param n - Number of rows
+ * @param k - Diagonal offset (0 = main, positive = above, negative = below)
+ * @param m - Number of columns (default n)
+ * @returns Tuple of row and column index arrays
+ */
+export declare function tril_indices(n: number, k?: number, m?: number): NDArray[];
+/**
+ * Return the indices for the lower-triangle of arr.
+ *
+ * @param arr - Input 2-D array
+ * @param k - Diagonal offset (0 = main, positive = above, negative = below)
+ * @returns Tuple of row and column index arrays
+ */
+export declare function tril_indices_from(arr: NDArray, k?: number): NDArray[];
+/**
+ * Return the indices for the upper-triangle of an (n, m) array.
+ *
+ * @param n - Number of rows
+ * @param k - Diagonal offset (0 = main, positive = above, negative = below)
+ * @param m - Number of columns (default n)
+ * @returns Tuple of row and column index arrays
+ */
+export declare function triu_indices(n: number, k?: number, m?: number): NDArray[];
+/**
+ * Return the indices for the upper-triangle of arr.
+ *
+ * @param arr - Input 2-D array
+ * @param k - Diagonal offset (0 = main, positive = above, negative = below)
+ * @returns Tuple of row and column index arrays
+ */
+export declare function triu_indices_from(arr: NDArray, k?: number): NDArray[];
+/**
+ * Return the indices to access (n, n) arrays, given a masking function.
+ *
+ * @param n - The returned indices will be valid to access arrays of shape (n, n)
+ * @param mask_func - A function that generates an (n, n) boolean mask
+ * @param k - Optional diagonal offset passed to mask_func
+ * @returns Tuple of row and column index arrays
+ */
+export declare function mask_indices(n: number, mask_func: (n: number, k: number) => NDArray, k?: number): NDArray[];
+/**
+ * Return an array representing the indices of a grid.
+ *
+ * @param dimensions - The shape of the grid
+ * @param dtype - Data type of result (default 'int32')
+ * @returns Array of shape (len(dimensions), *dimensions)
+ */
+export declare function indices(dimensions: number[], dtype?: 'int32' | 'int64' | 'float64'): NDArray;
+/**
+ * Construct an open mesh from multiple sequences.
+ *
+ * This function returns a list of arrays with shapes suitable for broadcasting.
+ *
+ * @param args - 1-D sequences
+ * @returns Tuple of arrays for open mesh
+ */
+export declare function ix_(...args: NDArray[]): NDArray[];
+/**
+ * Convert a tuple of index arrays into an array of flat indices.
+ *
+ * @param multi_index - Tuple of index arrays
+ * @param dims - Shape of array into which indices apply
+ * @param mode - How to handle out-of-bounds indices ('raise', 'wrap', 'clip')
+ * @returns Flattened indices
+ */
+export declare function ravel_multi_index(multi_index: NDArray[], dims: number[], mode?: 'raise' | 'wrap' | 'clip'): NDArray;
+/**
+ * Convert a flat index or array of flat indices into a tuple of coordinate arrays.
+ *
+ * @param indices - Array of indices or single index
+ * @param shape - Shape of the array to index into
+ * @param order - Row-major ('C') or column-major ('F') order
+ * @returns Tuple of coordinate arrays
+ */
+export declare function unravel_index(indices: NDArray | number, shape: number[], order?: 'C' | 'F'): NDArray[];
+/**
+ * Return a sorted copy of an array
+ * @param a - Input array
+ * @param axis - Axis along which to sort. Default is -1 (last axis)
+ * @returns Sorted array
+ */
+export declare function sort(a: NDArray, axis?: number): NDArray;
+/**
+ * Returns the indices that would sort an array
+ * @param a - Input array
+ * @param axis - Axis along which to sort. Default is -1 (last axis)
+ * @returns Array of indices that sort the input array
+ */
+export declare function argsort(a: NDArray, axis?: number): NDArray;
+/**
+ * Perform an indirect stable sort using a sequence of keys
+ * @param keys - Array of NDArrays, the last key is the primary sort key
+ * @returns Array of indices that would sort the keys
+ */
+export declare function lexsort(keys: NDArray[]): NDArray;
+/**
+ * Partially sort an array
+ * @param a - Input array
+ * @param kth - Element index to partition by
+ * @param axis - Axis along which to sort. Default is -1 (last axis)
+ * @returns Partitioned array
+ */
+export declare function partition(a: NDArray, kth: number, axis?: number): NDArray;
+/**
+ * Returns indices that would partition an array
+ * @param a - Input array
+ * @param kth - Element index to partition by
+ * @param axis - Axis along which to sort. Default is -1 (last axis)
+ * @returns Array of indices
+ */
+export declare function argpartition(a: NDArray, kth: number, axis?: number): NDArray;
+/**
+ * Sort a complex array using the real part first, then the imaginary part
+ * For real arrays, returns a sorted 1D array
+ * @param a - Input array
+ * @returns Sorted 1D array
+ */
+export declare function sort_complex(a: NDArray): NDArray;
+/**
+ * Return the indices of the elements that are non-zero
+ * @param a - Input array
+ * @returns Tuple of arrays, one for each dimension
+ */
+export declare function nonzero(a: NDArray): NDArray[];
+/**
+ * Return indices of non-zero elements in flattened array
+ * @param a - Input array
+ * @returns Array of indices
+ */
+export declare function flatnonzero(a: NDArray): NDArray;
+/**
+ * Return elements from x or y depending on condition
+ * If only condition is given, returns indices where condition is true (like nonzero)
+ * @param condition - Boolean array or condition
+ * @param x - Values where condition is true (optional)
+ * @param y - Values where condition is false (optional)
+ * @returns Array with elements chosen from x or y, or indices if only condition given
+ */
+export declare function where(condition: NDArray, x?: NDArray, y?: NDArray): NDArray | NDArray[];
+/**
+ * Find indices where elements should be inserted to maintain order
+ * @param a - Input array (must be sorted in ascending order)
+ * @param v - Values to insert
+ * @param side - 'left' or 'right' side to insert
+ * @returns Indices where values should be inserted
+ */
+export declare function searchsorted(a: NDArray, v: NDArray, side?: 'left' | 'right'): NDArray;
+/**
+ * Return the elements of an array that satisfy some condition
+ * @param condition - Boolean array
+ * @param a - Input array
+ * @returns 1D array of elements where condition is true
+ */
+export declare function extract(condition: NDArray, a: NDArray): NDArray;
+/**
+ * Count number of non-zero values in the array
+ * @param a - Input array
+ * @param axis - Axis along which to count (optional)
+ * @returns Count of non-zero values
+ */
+export declare function count_nonzero(a: NDArray, axis?: number): NDArray | number;
 //# sourceMappingURL=ndarray.d.ts.map

package/dist/types/index.d.ts

@@ -3,7 +3,7 @@
  *
  * @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, cumsum, cumprod, ptp, median, percentile, quantile, average, nansum, nanprod, nanmean, nanvar, nanstd, nanmin, nanmax, nanargmin, nanargmax, nancumsum, nancumprod, nanmedian, } 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, 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 { 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';
 export declare const __version__: string;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1,17 +1,18 @@
 /**
  * IO module for numpy-ts
  *
- * This module provides parsing and serialization for NPY and NPZ formats.
- * These functions work with bytes (Uint8Array/ArrayBuffer) and are environment-agnostic.
+ * This module provides parsing and serialization for NPY, NPZ, and text formats.
+ * These functions work with bytes/strings and are environment-agnostic.
  *
  * For file system operations (save/load), use the Node.js-specific entry point:
- *   import { save, load } from 'numpy-ts/node';
+ *   import { save, load, loadtxt, savetxt } from 'numpy-ts/node';
  *
- * For browser usage, use fetch or FileReader to get the bytes, then use these functions.
+ * For browser usage, use fetch or FileReader to get the bytes/text, then use these functions.
  */
 export { parseNpy, parseNpyHeader, parseNpyData } from './npy/parser';
 export { serializeNpy } from './npy/serializer';
 export { UnsupportedDTypeError, InvalidNpyError, SUPPORTED_DTYPES, DTYPE_TO_DESCR, type NpyHeader, type NpyMetadata, type NpyVersion, } from './npy/format';
 export { parseNpz, parseNpzSync, loadNpz, loadNpzSync, type NpzParseOptions, type NpzParseResult, } from './npz/parser';
 export { serializeNpz, serializeNpzSync, type NpzSerializeOptions } from './npz/serializer';
+export { parseTxt, genfromtxt, fromregex, serializeTxt, type ParseTxtOptions, type SerializeTxtOptions, } from './txt';
 //# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,12 @@
+/**
+ * Text I/O module for numpy-ts
+ *
+ * Provides parsing and serialization for delimited text formats (CSV, TSV, etc.).
+ * These functions work with strings and are environment-agnostic.
+ *
+ * For file system operations, use the Node.js-specific entry point:
+ *   import { loadtxt, savetxt } from 'numpy-ts/node';
+ */
+export { parseTxt, genfromtxt, fromregex, type ParseTxtOptions } from './parser';
+export { serializeTxt, type SerializeTxtOptions } from './serializer';
+//# sourceMappingURL=index.d.ts.map

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