numpy-ts 0.6.0 → 0.8.0

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/advanced.d.ts

@@ -37,4 +37,72 @@ export declare function choose(indexStorage: ArrayStorage, choices: ArrayStorage
  * Check if two arrays are element-wise equal
  */
 export declare function array_equal(a: ArrayStorage, b: ArrayStorage, equal_nan?: boolean): boolean;
+/**
+ * Take values along an axis using 1D index array
+ */
+export declare function take_along_axis(storage: ArrayStorage, indices: ArrayStorage, axis: number): ArrayStorage;
+/**
+ * Put values into array along an axis using 1D index array
+ */
+export declare function put_along_axis(storage: ArrayStorage, indices: ArrayStorage, values: ArrayStorage, axis: number): void;
+/**
+ * Change elements of array based on conditional mask
+ */
+export declare function putmask(storage: ArrayStorage, mask: ArrayStorage, values: ArrayStorage | number | bigint): void;
+/**
+ * Return selected slices along given axis based on condition
+ */
+export declare function compress(condition: ArrayStorage, storage: ArrayStorage, axis?: number): ArrayStorage;
+/**
+ * Return array drawn from elements in choicelist, depending on conditions
+ */
+export declare function select(condlist: ArrayStorage[], choicelist: ArrayStorage[], defaultValue?: number | bigint): ArrayStorage;
+/**
+ * Change elements of array based on conditional and input values
+ */
+export declare function place(storage: ArrayStorage, mask: ArrayStorage, vals: ArrayStorage): void;
+/**
+ * Return indices to access main diagonal of array
+ */
+export declare function diag_indices(n: number, ndim?: number): ArrayStorage[];
+/**
+ * Return indices to access main diagonal of array from given array
+ */
+export declare function diag_indices_from(storage: ArrayStorage): ArrayStorage[];
+/**
+ * Return indices for lower-triangle of an (n, m) array
+ */
+export declare function tril_indices(n: number, k?: number, m?: number): ArrayStorage[];
+/**
+ * Return indices for lower-triangle of given array
+ */
+export declare function tril_indices_from(storage: ArrayStorage, k?: number): ArrayStorage[];
+/**
+ * Return indices for upper-triangle of an (n, m) array
+ */
+export declare function triu_indices(n: number, k?: number, m?: number): ArrayStorage[];
+/**
+ * Return indices for upper-triangle of given array
+ */
+export declare function triu_indices_from(storage: ArrayStorage, k?: number): ArrayStorage[];
+/**
+ * Return indices to access elements using mask function
+ */
+export declare function mask_indices(n: number, mask_func: (n: number, k: number) => ArrayStorage, k?: number): ArrayStorage[];
+/**
+ * Return array representing indices of a grid
+ */
+export declare function indices(dimensions: number[], dtype?: 'int32' | 'int64' | 'float64'): ArrayStorage;
+/**
+ * Construct open mesh from multiple sequences
+ */
+export declare function ix_(...args: ArrayStorage[]): ArrayStorage[];
+/**
+ * Convert multi-dimensional index arrays to flat index array
+ */
+export declare function ravel_multi_index(multi_index: ArrayStorage[], dims: number[], mode?: 'raise' | 'wrap' | 'clip'): ArrayStorage;
+/**
+ * Convert flat index array to tuple of coordinate arrays
+ */
+export declare function unravel_index(indices: ArrayStorage | number, shape: number[], order?: 'C' | 'F'): ArrayStorage[];
 //# sourceMappingURL=advanced.d.ts.map

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

@@ -0,0 +1,91 @@
+/**
+ * Bitwise operations
+ *
+ * Pure functions for element-wise bitwise operations:
+ * bitwise_and, bitwise_or, bitwise_xor, bitwise_not, invert,
+ * left_shift, right_shift, packbits, unpackbits
+ *
+ * These operations only work on integer types.
+ */
+import { ArrayStorage } from '../core/storage';
+/**
+ * Bitwise AND of two arrays or array and scalar
+ *
+ * @param a - First array storage (must be integer type)
+ * @param b - Second array storage or scalar (must be integer type)
+ * @returns Result storage
+ */
+export declare function bitwise_and(a: ArrayStorage, b: ArrayStorage | number): ArrayStorage;
+/**
+ * Bitwise OR of two arrays or array and scalar
+ *
+ * @param a - First array storage (must be integer type)
+ * @param b - Second array storage or scalar (must be integer type)
+ * @returns Result storage
+ */
+export declare function bitwise_or(a: ArrayStorage, b: ArrayStorage | number): ArrayStorage;
+/**
+ * Bitwise XOR of two arrays or array and scalar
+ *
+ * @param a - First array storage (must be integer type)
+ * @param b - Second array storage or scalar (must be integer type)
+ * @returns Result storage
+ */
+export declare function bitwise_xor(a: ArrayStorage, b: ArrayStorage | number): ArrayStorage;
+/**
+ * Bitwise NOT (invert) of each element
+ *
+ * @param a - Input array storage (must be integer type)
+ * @returns Result storage with bitwise NOT values
+ */
+export declare function bitwise_not(a: ArrayStorage): ArrayStorage;
+/**
+ * Invert (bitwise NOT) - alias for bitwise_not
+ *
+ * @param a - Input array storage (must be integer type)
+ * @returns Result storage with inverted values
+ */
+export declare function invert(a: ArrayStorage): ArrayStorage;
+/**
+ * Left shift of array elements
+ *
+ * @param a - Input array storage (must be integer type)
+ * @param b - Shift amount (array storage or scalar)
+ * @returns Result storage with left-shifted values
+ */
+export declare function left_shift(a: ArrayStorage, b: ArrayStorage | number): ArrayStorage;
+/**
+ * Right shift of array elements
+ *
+ * @param a - Input array storage (must be integer type)
+ * @param b - Shift amount (array storage or scalar)
+ * @returns Result storage with right-shifted values
+ */
+export declare function right_shift(a: ArrayStorage, b: ArrayStorage | number): ArrayStorage;
+/**
+ * Pack binary values into uint8 array
+ *
+ * Packs the elements of a binary-valued array into bits in a uint8 array.
+ * The result has the same shape as the input, except for the specified axis
+ * which is divided by 8 (rounded up).
+ *
+ * @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, meaning the last axis)
+ * @param bitorder - The order of bits within each packed byte. 'big' means the most significant bit is first. (default: 'big')
+ * @returns Packed uint8 array
+ */
+export declare function packbits(a: ArrayStorage, axis?: number, bitorder?: 'big' | 'little'): ArrayStorage;
+/**
+ * Unpack uint8 array into binary values
+ *
+ * Unpacks elements of a uint8 array into a binary-valued output array.
+ * Each element of the input array is unpacked into 8 binary values.
+ *
+ * @param a - Input uint8 array
+ * @param axis - The dimension over which bit-unpacking is done (default: -1, meaning the last axis)
+ * @param count - The number of elements to unpack along axis, or -1 for all (default: -1)
+ * @param bitorder - The order of bits within each packed byte. 'big' means the most significant bit is first. (default: 'big')
+ * @returns Unpacked uint8 array of 0s and 1s
+ */
+export declare function unpackbits(a: ArrayStorage, axis?: number, count?: number, bitorder?: 'big' | 'little'): ArrayStorage;
+//# sourceMappingURL=bitwise.d.ts.map

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

@@ -0,0 +1,95 @@
+/**
+ * Sorting and searching operations
+ *
+ * Functions for sorting arrays, finding sorted indices, and searching.
+ * @module ops/sorting
+ */
+import { ArrayStorage } from '../core/storage';
+/**
+ * Return a sorted copy of an array
+ * @param storage - Input array storage
+ * @param axis - Axis along which to sort. Default is -1 (last axis)
+ * @returns Sorted array
+ */
+export declare function sort(storage: ArrayStorage, axis?: number): ArrayStorage;
+/**
+ * Returns the indices that would sort an array
+ * @param storage - Input array storage
+ * @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(storage: ArrayStorage, axis?: number): ArrayStorage;
+/**
+ * Perform an indirect stable sort using a sequence of keys
+ * @param keys - Array of ArrayStorage, the last key is the primary sort key
+ * @returns Array of indices that would sort the keys
+ */
+export declare function lexsort(keys: ArrayStorage[]): ArrayStorage;
+/**
+ * Partially sort an array
+ * Returns array with element at kth position in sorted position,
+ * all smaller elements before it, all larger after it (not fully sorted)
+ * @param storage - Input array storage
+ * @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(storage: ArrayStorage, kth: number, axis?: number): ArrayStorage;
+/**
+ * Returns indices that would partition an array
+ * @param storage - Input array storage
+ * @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(storage: ArrayStorage, kth: number, axis?: number): ArrayStorage;
+/**
+ * Sort a complex array using the real part first, then the imaginary part
+ * For real arrays, this is equivalent to sort
+ * @param storage - Input array storage
+ * @returns Sorted array
+ */
+export declare function sort_complex(storage: ArrayStorage): ArrayStorage;
+/**
+ * Return the indices of the elements that are non-zero
+ * @param storage - Input array storage
+ * @returns Tuple of arrays, one for each dimension
+ */
+export declare function nonzero(storage: ArrayStorage): ArrayStorage[];
+/**
+ * Return indices of non-zero elements in flattened array
+ * @param storage - Input array storage
+ * @returns Array of indices
+ */
+export declare function flatnonzero(storage: ArrayStorage): ArrayStorage;
+/**
+ * Return elements from x or y depending on condition
+ * @param condition - Boolean array or condition
+ * @param x - Values where condition is true
+ * @param y - Values where condition is false
+ * @returns Array with elements chosen from x or y based on condition
+ */
+export declare function where(condition: ArrayStorage, x?: ArrayStorage, y?: ArrayStorage): ArrayStorage | ArrayStorage[];
+/**
+ * Find indices where elements should be inserted to maintain order
+ * @param storage - Input array (must be sorted in ascending order)
+ * @param values - Values to insert
+ * @param side - 'left' or 'right' side to insert
+ * @returns Indices where values should be inserted
+ */
+export declare function searchsorted(storage: ArrayStorage, values: ArrayStorage, side?: 'left' | 'right'): ArrayStorage;
+/**
+ * Return the elements of an array that satisfy some condition
+ * @param condition - Boolean array
+ * @param storage - Input array storage
+ * @returns 1D array of elements where condition is true
+ */
+export declare function extract(condition: ArrayStorage, storage: ArrayStorage): ArrayStorage;
+/**
+ * Count number of non-zero values in the array
+ * @param storage - Input array storage
+ * @param axis - Axis along which to count (optional)
+ * @returns Count of non-zero values
+ */
+export declare function count_nonzero(storage: ArrayStorage, axis?: number): ArrayStorage | number;
+//# sourceMappingURL=sorting.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "numpy-ts",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "Complete NumPy implementation for TypeScript and JavaScript (under construction)",
   "main": "dist/numpy-ts.node.cjs",
   "browser": "dist/numpy-ts.browser.js",