numpy-ts 0.4.0 → 0.5.0

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

@@ -0,0 +1,7 @@
+/**
+ * Minimal ZIP file reading and writing
+ */
+export { readZip, readZipSync } from './reader';
+export { writeZip, writeZipSync, type ZipWriteOptions } from './writer';
+export { crc32, ZIP_STORED, ZIP_DEFLATED } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/io/zip/reader.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Minimal ZIP file reader
+ *
+ * Reads ZIP files with STORED or DEFLATE compression.
+ * Uses the Compression Streams API (built into modern browsers and Node.js 18+).
+ */
+/**
+ * Read a ZIP file and return its entries
+ *
+ * @param buffer - ZIP file contents
+ * @returns Map of file names to their uncompressed data
+ */
+export declare function readZip(buffer: ArrayBuffer | Uint8Array): Promise<Map<string, Uint8Array>>;
+/**
+ * Synchronously read a ZIP file (only works for STORED entries)
+ *
+ * @param buffer - ZIP file contents
+ * @returns Map of file names to their uncompressed data
+ * @throws Error if any entry uses compression
+ */
+export declare function readZipSync(buffer: ArrayBuffer | Uint8Array): Map<string, Uint8Array>;
+//# sourceMappingURL=reader.d.ts.map

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

@@ -0,0 +1,59 @@
+/**
+ * ZIP file format types and constants
+ */
+/**
+ * ZIP local file header signature
+ */
+export declare const ZIP_LOCAL_SIGNATURE = 67324752;
+/**
+ * ZIP central directory header signature
+ */
+export declare const ZIP_CENTRAL_SIGNATURE = 33639248;
+/**
+ * ZIP end of central directory signature
+ */
+export declare const ZIP_END_SIGNATURE = 101010256;
+/**
+ * Compression methods
+ */
+export declare const ZIP_STORED = 0;
+export declare const ZIP_DEFLATED = 8;
+/**
+ * Entry in a ZIP file
+ */
+export interface ZipEntry {
+    /** File name */
+    name: string;
+    /** Uncompressed data */
+    data: Uint8Array;
+    /** Compression method used */
+    compressionMethod: number;
+    /** CRC-32 checksum */
+    crc32: number;
+    /** Compressed size */
+    compressedSize: number;
+    /** Uncompressed size */
+    uncompressedSize: number;
+}
+/**
+ * Raw entry as read from ZIP (before decompression)
+ */
+export interface RawZipEntry {
+    /** File name */
+    name: string;
+    /** Compressed data */
+    compressedData: Uint8Array;
+    /** Compression method */
+    compressionMethod: number;
+    /** CRC-32 checksum */
+    crc32: number;
+    /** Compressed size */
+    compressedSize: number;
+    /** Uncompressed size */
+    uncompressedSize: number;
+}
+/**
+ * Calculate CRC-32 checksum
+ */
+export declare function crc32(data: Uint8Array): number;
+//# sourceMappingURL=types.d.ts.map

package/dist/types/io/zip/writer.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Minimal ZIP file writer
+ *
+ * Creates ZIP files with optional DEFLATE compression.
+ * Uses the Compression Streams API (built into modern browsers and Node.js 18+).
+ */
+/**
+ * Options for writing a ZIP file
+ */
+export interface ZipWriteOptions {
+    /** Whether to compress files (default: false for NPZ compatibility) */
+    compress?: boolean;
+}
+/**
+ * Create a ZIP file from a map of file names to data
+ *
+ * @param files - Map of file names to their data
+ * @param options - Write options
+ * @returns ZIP file as Uint8Array
+ */
+export declare function writeZip(files: Map<string, Uint8Array>, options?: ZipWriteOptions): Promise<Uint8Array>;
+/**
+ * Create a ZIP file synchronously (no compression)
+ *
+ * @param files - Map of file names to their data
+ * @returns ZIP file as Uint8Array
+ */
+export declare function writeZipSync(files: Map<string, Uint8Array>): Uint8Array;
+//# sourceMappingURL=writer.d.ts.map

package/dist/types/node.d.ts

@@ -0,0 +1,154 @@
+/**
+ * Node.js-specific entry point for numpy-ts
+ *
+ * This module provides file system operations for saving and loading NPY/NPZ files,
+ * plus all core numpy-ts functionality in a single import.
+ *
+ * Usage:
+ *   import * as np from 'numpy-ts/node';
+ *   // Has everything from numpy-ts + file I/O
+ *   const arr = await np.loadNpy('data.npy');
+ *   await np.saveNpz('output.npz', { x: arr });
+ *
+ * For browser usage, use the main entry point (no file I/O).
+ */
+import { NDArray } from './core/ndarray';
+import { type NpzParseOptions, type NpzParseResult } from './io/npz/parser';
+import { type NpzSerializeOptions, type NpzArraysInput } from './io/npz/serializer';
+export * from './index';
+export * from './io';
+/**
+ * Options for loading NPY/NPZ files
+ */
+export interface LoadOptions extends NpzParseOptions {
+    /**
+     * If true, allow loading .npy files.
+     * Default: true
+     */
+    allowNpy?: boolean;
+}
+/**
+ * Options for saving NPZ files
+ */
+export interface SaveNpzOptions extends NpzSerializeOptions {
+}
+/**
+ * Load an NDArray from a .npy file
+ *
+ * @param path - Path to the .npy file
+ * @returns The loaded NDArray
+ */
+export declare function loadNpy(path: string): Promise<NDArray>;
+/**
+ * Synchronously load an NDArray from a .npy file
+ *
+ * @param path - Path to the .npy file
+ * @returns The loaded NDArray
+ */
+export declare function loadNpySync(path: string): NDArray;
+/**
+ * Save an NDArray to a .npy file
+ *
+ * @param path - Path to save the .npy file
+ * @param arr - The NDArray to save
+ */
+export declare function saveNpy(path: string, arr: NDArray): Promise<void>;
+/**
+ * Synchronously save an NDArray to a .npy file
+ *
+ * @param path - Path to save the .npy file
+ * @param arr - The NDArray to save
+ */
+export declare function saveNpySync(path: string, arr: NDArray): void;
+/**
+ * Load arrays from a .npz file
+ *
+ * @param path - Path to the .npz file
+ * @param options - Load options
+ * @returns Object with array names as keys
+ */
+export declare function loadNpzFile(path: string, options?: NpzParseOptions): Promise<NpzParseResult>;
+/**
+ * Synchronously load arrays from a .npz file
+ *
+ * Note: Only works if the NPZ file is not DEFLATE compressed.
+ *
+ * @param path - Path to the .npz file
+ * @param options - Load options
+ * @returns Object with array names as keys
+ */
+export declare function loadNpzFileSync(path: string, options?: NpzParseOptions): NpzParseResult;
+/**
+ * Save arrays to a .npz file
+ *
+ * @param path - Path to save the .npz file
+ * @param arrays - Arrays to save:
+ *   - Array of NDArrays (positional, named arr_0, arr_1, etc.)
+ *   - Map of names to NDArrays
+ *   - Object with names as keys
+ * @param options - Save options
+ */
+export declare function saveNpz(path: string, arrays: NpzArraysInput, options?: SaveNpzOptions): Promise<void>;
+/**
+ * Synchronously save arrays to a .npz file (no compression)
+ *
+ * @param path - Path to save the .npz file
+ * @param arrays - Arrays to save (same types as saveNpz)
+ */
+export declare function saveNpzSync(path: string, arrays: NpzArraysInput): void;
+/**
+ * Load an array or arrays from a .npy or .npz file
+ *
+ * This is a convenience function that auto-detects the file format based on extension.
+ *
+ * @param path - Path to the file
+ * @param options - Load options
+ * @returns NDArray for .npy files, or NpzParseResult for .npz files
+ */
+export declare function load(path: string, options?: LoadOptions): Promise<NDArray | NpzParseResult>;
+/**
+ * Synchronously load an array or arrays from a .npy or .npz file
+ *
+ * @param path - Path to the file
+ * @param options - Load options
+ * @returns NDArray for .npy files, or NpzParseResult for .npz files
+ */
+export declare function loadSync(path: string, options?: LoadOptions): NDArray | NpzParseResult;
+/**
+ * Save an array to a .npy file
+ *
+ * @param path - Path to save the file (should end with .npy)
+ * @param arr - The NDArray to save
+ */
+export declare function save(path: string, arr: NDArray): Promise<void>;
+/**
+ * Synchronously save an array to a .npy file
+ *
+ * @param path - Path to save the file (should end with .npy)
+ * @param arr - The NDArray to save
+ */
+export declare function saveSync(path: string, arr: NDArray): void;
+/**
+ * Save multiple arrays to a .npz file (like np.savez)
+ *
+ * @param path - Path to save the .npz file
+ * @param arrays - Arrays to save:
+ *   - Array of NDArrays: named arr_0, arr_1, etc. (like np.savez positional args)
+ *   - Object/Map with names as keys (like np.savez keyword args)
+ *
+ * @example
+ * // Positional arrays
+ * await savez('data.npz', [arr1, arr2])  // saved as arr_0, arr_1
+ *
+ * // Named arrays
+ * await savez('data.npz', { x: arr1, y: arr2 })
+ */
+export declare function savez(path: string, arrays: NpzArraysInput): Promise<void>;
+/**
+ * Save multiple arrays to a compressed .npz file (like np.savez_compressed)
+ *
+ * @param path - Path to save the .npz file
+ * @param arrays - Arrays to save (same input types as savez)
+ */
+export declare function savez_compressed(path: string, arrays: NpzArraysInput): Promise<void>;
+//# sourceMappingURL=node.d.ts.map

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

@@ -0,0 +1,34 @@
+/**
+ * Advanced array operations
+ *
+ * Broadcasting, indexing, and comparison functions.
+ * @module ops/advanced
+ */
+import { ArrayStorage } from '../core/storage';
+/**
+ * Broadcast an array to a given shape
+ * Returns a read-only view on the original array
+ */
+export declare function broadcast_to(storage: ArrayStorage, targetShape: number[]): ArrayStorage;
+/**
+ * Broadcast multiple arrays to a common shape
+ * Returns views on the original arrays
+ */
+export declare function broadcast_arrays(storages: ArrayStorage[]): ArrayStorage[];
+/**
+ * Take elements from an array along an axis
+ */
+export declare function take(storage: ArrayStorage, indices: number[], axis?: number): ArrayStorage;
+/**
+ * Put values at specified indices (modifies array in-place)
+ */
+export declare function put(storage: ArrayStorage, indices: number[], values: ArrayStorage | number | bigint): void;
+/**
+ * Construct array from index array and choices
+ */
+export declare function choose(indexStorage: ArrayStorage, choices: ArrayStorage[]): ArrayStorage;
+/**
+ * Check if two arrays are element-wise equal
+ */
+export declare function array_equal(a: ArrayStorage, b: ArrayStorage, equal_nan?: boolean): boolean;
+//# sourceMappingURL=advanced.d.ts.map

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

@@ -0,0 +1,59 @@
+/**
+ * Hyperbolic operations
+ *
+ * Pure functions for element-wise hyperbolic operations:
+ * sinh, cosh, tanh, arcsinh, arccosh, arctanh
+ *
+ * These functions are used by NDArray methods but are separated
+ * to keep the codebase modular and testable.
+ */
+import { ArrayStorage } from '../core/storage';
+/**
+ * Hyperbolic sine of each element (element-wise)
+ * NumPy behavior: Always promotes to float64 for integer types
+ *
+ * @param a - Input array storage
+ * @returns Result storage with sinh applied
+ */
+export declare function sinh(a: ArrayStorage): ArrayStorage;
+/**
+ * Hyperbolic cosine of each element (element-wise)
+ * NumPy behavior: Always promotes to float64 for integer types
+ *
+ * @param a - Input array storage
+ * @returns Result storage with cosh applied
+ */
+export declare function cosh(a: ArrayStorage): ArrayStorage;
+/**
+ * Hyperbolic tangent of each element (element-wise)
+ * NumPy behavior: Always promotes to float64 for integer types
+ *
+ * @param a - Input array storage
+ * @returns Result storage with tanh applied
+ */
+export declare function tanh(a: ArrayStorage): ArrayStorage;
+/**
+ * Inverse hyperbolic sine of each element (element-wise)
+ * NumPy behavior: Always promotes to float64 for integer types
+ *
+ * @param a - Input array storage
+ * @returns Result storage with arcsinh applied
+ */
+export declare function arcsinh(a: ArrayStorage): ArrayStorage;
+/**
+ * Inverse hyperbolic cosine of each element (element-wise)
+ * NumPy behavior: Always promotes to float64 for integer types
+ *
+ * @param a - Input array storage (values >= 1)
+ * @returns Result storage with arccosh applied
+ */
+export declare function arccosh(a: ArrayStorage): ArrayStorage;
+/**
+ * Inverse hyperbolic tangent of each element (element-wise)
+ * NumPy behavior: Always promotes to float64 for integer types
+ *
+ * @param a - Input array storage (values in range (-1, 1))
+ * @returns Result storage with arctanh applied
+ */
+export declare function arctanh(a: ArrayStorage): ArrayStorage;
+//# sourceMappingURL=hyperbolic.d.ts.map

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

@@ -36,4 +36,65 @@ export declare function squeeze(storage: ArrayStorage, axis?: number): ArrayStor
  * Returns a view with additional dimension
  */
 export declare function expandDims(storage: ArrayStorage, axis: number): ArrayStorage;
+/**
+ * Swap two axes of an array
+ * Returns a view with axes swapped
+ */
+export declare function swapaxes(storage: ArrayStorage, axis1: number, axis2: number): ArrayStorage;
+/**
+ * Move axes to new positions
+ * Returns a view with axes moved
+ */
+export declare function moveaxis(storage: ArrayStorage, source: number | number[], destination: number | number[]): ArrayStorage;
+/**
+ * Concatenate arrays along an axis
+ */
+export declare function concatenate(storages: ArrayStorage[], axis?: number): ArrayStorage;
+/**
+ * Stack arrays along a new axis
+ */
+export declare function stack(storages: ArrayStorage[], axis?: number): ArrayStorage;
+/**
+ * Stack arrays vertically (row-wise)
+ * vstack is equivalent to concatenation along the first axis after
+ * 1-D arrays of shape (N,) have been reshaped to (1,N)
+ */
+export declare function vstack(storages: ArrayStorage[]): ArrayStorage;
+/**
+ * Stack arrays horizontally (column-wise)
+ * hstack is equivalent to concatenation along the second axis,
+ * except for 1-D arrays where it concatenates along the first axis
+ */
+export declare function hstack(storages: ArrayStorage[]): ArrayStorage;
+/**
+ * Stack arrays depth-wise (along third axis)
+ * dstack is equivalent to concatenation along the third axis after
+ * 2-D arrays of shape (M,N) have been reshaped to (M,N,1) and
+ * 1-D arrays of shape (N,) have been reshaped to (1,N,1)
+ */
+export declare function dstack(storages: ArrayStorage[]): ArrayStorage;
+/**
+ * Split array into sub-arrays
+ */
+export declare function split(storage: ArrayStorage, indicesOrSections: number | number[], axis?: number): ArrayStorage[];
+/**
+ * Split array into sub-arrays (allows unequal splits)
+ */
+export declare function arraySplit(storage: ArrayStorage, indicesOrSections: number | number[], axis?: number): ArrayStorage[];
+/**
+ * Split array vertically (row-wise)
+ */
+export declare function vsplit(storage: ArrayStorage, indicesOrSections: number | number[]): ArrayStorage[];
+/**
+ * Split array horizontally (column-wise)
+ */
+export declare function hsplit(storage: ArrayStorage, indicesOrSections: number | number[]): ArrayStorage[];
+/**
+ * Tile array by repeating along each axis
+ */
+export declare function tile(storage: ArrayStorage, reps: number | number[]): ArrayStorage;
+/**
+ * Repeat elements of an array
+ */
+export declare function repeat(storage: ArrayStorage, repeats: number | number[], axis?: number): ArrayStorage;
 //# sourceMappingURL=shape.d.ts.map

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

@@ -0,0 +1,94 @@
+/**
+ * Trigonometric operations
+ *
+ * Pure functions for element-wise trigonometric operations:
+ * sin, cos, tan, arcsin, arccos, arctan, arctan2, hypot, degrees, radians
+ *
+ * These functions are used by NDArray methods but are separated
+ * to keep the codebase modular and testable.
+ */
+import { ArrayStorage } from '../core/storage';
+/**
+ * Sine of each element (element-wise)
+ * NumPy behavior: Always promotes to float64 for integer types
+ *
+ * @param a - Input array storage (angles in radians)
+ * @returns Result storage with sin applied
+ */
+export declare function sin(a: ArrayStorage): ArrayStorage;
+/**
+ * Cosine of each element (element-wise)
+ * NumPy behavior: Always promotes to float64 for integer types
+ *
+ * @param a - Input array storage (angles in radians)
+ * @returns Result storage with cos applied
+ */
+export declare function cos(a: ArrayStorage): ArrayStorage;
+/**
+ * Tangent of each element (element-wise)
+ * NumPy behavior: Always promotes to float64 for integer types
+ *
+ * @param a - Input array storage (angles in radians)
+ * @returns Result storage with tan applied
+ */
+export declare function tan(a: ArrayStorage): ArrayStorage;
+/**
+ * Inverse sine of each element (element-wise)
+ * NumPy behavior: Always promotes to float64 for integer types
+ *
+ * @param a - Input array storage (values in range [-1, 1])
+ * @returns Result storage with arcsin applied (radians)
+ */
+export declare function arcsin(a: ArrayStorage): ArrayStorage;
+/**
+ * Inverse cosine of each element (element-wise)
+ * NumPy behavior: Always promotes to float64 for integer types
+ *
+ * @param a - Input array storage (values in range [-1, 1])
+ * @returns Result storage with arccos applied (radians)
+ */
+export declare function arccos(a: ArrayStorage): ArrayStorage;
+/**
+ * Inverse tangent of each element (element-wise)
+ * NumPy behavior: Always promotes to float64 for integer types
+ *
+ * @param a - Input array storage
+ * @returns Result storage with arctan applied (radians)
+ */
+export declare function arctan(a: ArrayStorage): ArrayStorage;
+/**
+ * Element-wise arc tangent of x1/x2 choosing the quadrant correctly.
+ * NumPy behavior: Always promotes to float64 for integer types
+ *
+ * @param x1 - y-coordinates
+ * @param x2 - x-coordinates (array storage or scalar)
+ * @returns Angle in radians between -π and π
+ */
+export declare function arctan2(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
+/**
+ * Given the "legs" of a right triangle, return its hypotenuse.
+ * Equivalent to sqrt(x1**2 + x2**2), element-wise.
+ * NumPy behavior: Always promotes to float64 for integer types
+ *
+ * @param x1 - First leg
+ * @param x2 - Second leg (array storage or scalar)
+ * @returns Hypotenuse
+ */
+export declare function hypot(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
+/**
+ * Convert angles from radians to degrees.
+ * NumPy behavior: Always promotes to float64 for integer types
+ *
+ * @param a - Input array storage (angles in radians)
+ * @returns Angles in degrees
+ */
+export declare function degrees(a: ArrayStorage): ArrayStorage;
+/**
+ * Convert angles from degrees to radians.
+ * NumPy behavior: Always promotes to float64 for integer types
+ *
+ * @param a - Input array storage (angles in degrees)
+ * @returns Angles in radians
+ */
+export declare function radians(a: ArrayStorage): ArrayStorage;
+//# sourceMappingURL=trig.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "numpy-ts",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Complete NumPy implementation for TypeScript and JavaScript (under construction)",
   "main": "dist/numpy-ts.node.cjs",
   "browser": "dist/numpy-ts.browser.js",
@@ -10,6 +10,9 @@
   "files": [
     "dist/**/*.js",
     "dist/**/*.cjs",
+    "dist/**/*.mjs",
+    "dist/**/*.cjs.map",
+    "dist/**/*.mjs.map",
     "dist/types/**/*.d.ts",
     "README.md",
     "LICENSE"
@@ -23,10 +26,18 @@
     },
     "./node": {
       "types": "./dist/types/node.d.ts",
-      "default": "./dist/numpy-ts.node.cjs"
+      "import": "./dist/numpy-ts.node-io.mjs",
+      "require": "./dist/numpy-ts.node-io.cjs",
+      "default": "./dist/numpy-ts.node-io.cjs"
+    },
+    "./io": {
+      "types": "./dist/types/io/index.d.ts",
+      "node": "./dist/numpy-ts.node.cjs",
+      "browser": "./dist/numpy-ts.browser.js",
+      "default": "./dist/numpy-ts.esm.js"
     },
     "./browser": {
-      "types": "./dist/types/browser.d.ts",
+      "types": "./dist/types/index.d.ts",
       "default": "./dist/numpy-ts.browser.js"
     }
   },
@@ -57,7 +68,8 @@
     "bench:large": "npm run bench:build && node benchmarks/dist/bench.cjs --large",
     "bench:category": "npm run bench:build && node benchmarks/dist/bench.cjs --category",
     "bench:view": "open benchmarks/results/plots/latest.html || xdg-open benchmarks/results/plots/latest.html",
-    "bench:large:view": "open benchmarks/results/plots/latest-large.html || xdg-open benchmarks/results/plots/latest-large.html"
+    "bench:large:view": "open benchmarks/results/plots/latest-large.html || xdg-open benchmarks/results/plots/latest-large.html",
+    "compare-api": "python3 scripts/compare-api-coverage.py"
   },
   "keywords": [
     "numpy",
@@ -81,7 +93,7 @@
   "bugs": {
     "url": "https://github.com/dupontcyborg/numpy-ts/issues"
   },
-  "homepage": "https://github.com/dupontcyborg/numpy-ts#readme",
+  "homepage": "https://github.com/dupontcyborg/numpy-ts",
   "devDependencies": {
     "@types/node": "^24.9.1",
     "@typescript-eslint/eslint-plugin": "^8.46.2",
@@ -105,7 +117,7 @@
     "vitest": "^4.0.3"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20.1.0"
   },
   "overrides": {
     "js-yaml": ">=4.1.1"