numpy-ts 0.4.0 → 0.6.0

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

@@ -40,4 +40,16 @@ export declare function isclose(a: ArrayStorage, b: ArrayStorage | number, rtol?
  * Returns true if all elements satisfy isclose condition
  */
 export declare function allclose(a: ArrayStorage, b: ArrayStorage | number, rtol?: number, atol?: number): boolean;
+/**
+ * Returns True if two arrays are element-wise equal within a tolerance.
+ * Unlike array_equal, this function broadcasts the arrays before comparison.
+ *
+ * NumPy behavior: Broadcasts arrays before comparing, returns True if shapes
+ * are broadcast-compatible and all elements are equal.
+ *
+ * @param a1 - First input array
+ * @param a2 - Second input array
+ * @returns True if arrays are equivalent (after broadcasting), False otherwise
+ */
+export declare function arrayEquiv(a1: ArrayStorage, a2: ArrayStorage): boolean;
 //# sourceMappingURL=comparison.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/linalg.d.ts

@@ -92,4 +92,55 @@ export declare function outer(a: ArrayStorage, b: ArrayStorage): ArrayStorage;
  * @returns Tensor dot product
  */
 export declare function tensordot(a: ArrayStorage, b: ArrayStorage, axes: number | [number[], number[]]): ArrayStorage | number | bigint;
+/**
+ * Extract a diagonal or construct a diagonal array.
+ *
+ * NumPy behavior:
+ * - For 2D arrays: extract the k-th diagonal
+ * - For ND arrays (N >= 2): extract diagonal from the axes specified
+ * - Returns a view when possible, copy otherwise
+ *
+ * @param a - Input array (must be at least 2D)
+ * @param offset - Offset of the diagonal from the main diagonal (default: 0)
+ *                 - offset > 0: diagonal above main diagonal
+ *                 - offset < 0: diagonal below main diagonal
+ * @param axis1 - First axis for ND arrays (default: 0)
+ * @param axis2 - Second axis for ND arrays (default: 1)
+ * @returns Array containing the diagonal elements
+ */
+export declare function diagonal(a: ArrayStorage, offset?: number, axis1?: number, axis2?: number): ArrayStorage;
+/**
+ * Einstein summation convention
+ *
+ * Performs tensor contractions and reductions using Einstein summation notation.
+ *
+ * Examples:
+ * - 'ij,jk->ik': matrix multiplication
+ * - 'i,i->': dot product (inner product)
+ * - 'ij->ji': transpose
+ * - 'ii->': trace
+ * - 'ij->j': sum over first axis
+ * - 'ijk,ikl->ijl': batched matrix multiplication
+ *
+ * @param subscripts - Einstein summation subscripts (e.g., 'ij,jk->ik')
+ * @param operands - Input arrays
+ * @returns Result of the Einstein summation
+ */
+export declare function einsum(subscripts: string, ...operands: ArrayStorage[]): ArrayStorage | number | bigint;
+/**
+ * Kronecker product of two arrays.
+ *
+ * Computes the Kronecker product, a composite array made of blocks of the
+ * second array scaled by the elements of the first.
+ *
+ * NumPy behavior:
+ * - If both inputs are vectors (1D), output is also a vector
+ * - If both inputs are 2D matrices, output shape is (m1*m2, n1*n2)
+ * - General case: broadcasts shapes then computes block product
+ *
+ * @param a - First input array
+ * @param b - Second input array
+ * @returns Kronecker product of a and b
+ */
+export declare function kron(a: ArrayStorage, b: ArrayStorage): ArrayStorage;
 //# sourceMappingURL=linalg.d.ts.map

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

@@ -58,4 +58,80 @@ export declare function all(storage: ArrayStorage, axis?: number, keepdims?: boo
  * Test whether any array elements along a given axis evaluate to True
  */
 export declare function any(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | boolean;
+/**
+ * Return cumulative sum of elements along a given axis
+ */
+export declare function cumsum(storage: ArrayStorage, axis?: number): ArrayStorage;
+/**
+ * Return cumulative product of elements along a given axis
+ */
+export declare function cumprod(storage: ArrayStorage, axis?: number): ArrayStorage;
+/**
+ * Peak to peak (maximum - minimum) value along a given axis
+ */
+export declare function ptp(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
+/**
+ * Compute the median along the specified axis
+ */
+export declare function median(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
+/**
+ * Compute the q-th percentile of data along specified axis
+ */
+export declare function percentile(storage: ArrayStorage, q: number, axis?: number, keepdims?: boolean): ArrayStorage | number;
+/**
+ * Compute the q-th quantile of data along specified axis
+ */
+export declare function quantile(storage: ArrayStorage, q: number, axis?: number, keepdims?: boolean): ArrayStorage | number;
+/**
+ * Compute the weighted average along the specified axis
+ */
+export declare function average(storage: ArrayStorage, axis?: number, weights?: ArrayStorage, keepdims?: boolean): ArrayStorage | number;
+/**
+ * Return sum of elements, treating NaNs as zero
+ */
+export declare function nansum(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
+/**
+ * Return product of elements, treating NaNs as one
+ */
+export declare function nanprod(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
+/**
+ * Compute mean ignoring NaN values
+ */
+export declare function nanmean(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
+/**
+ * Compute variance ignoring NaN values
+ */
+export declare function nanvar(storage: ArrayStorage, axis?: number, ddof?: number, keepdims?: boolean): ArrayStorage | number;
+/**
+ * Compute standard deviation ignoring NaN values
+ */
+export declare function nanstd(storage: ArrayStorage, axis?: number, ddof?: number, keepdims?: boolean): ArrayStorage | number;
+/**
+ * Return minimum ignoring NaN values
+ */
+export declare function nanmin(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
+/**
+ * Return maximum ignoring NaN values
+ */
+export declare function nanmax(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
+/**
+ * Return indices of minimum value, ignoring NaNs
+ */
+export declare function nanargmin(storage: ArrayStorage, axis?: number): ArrayStorage | number;
+/**
+ * Return indices of maximum value, ignoring NaNs
+ */
+export declare function nanargmax(storage: ArrayStorage, axis?: number): ArrayStorage | number;
+/**
+ * Return cumulative sum, treating NaNs as zero
+ */
+export declare function nancumsum(storage: ArrayStorage, axis?: number): ArrayStorage;
+/**
+ * Return cumulative product, treating NaNs as one
+ */
+export declare function nancumprod(storage: ArrayStorage, axis?: number): ArrayStorage;
+/**
+ * Compute median ignoring NaN values
+ */
+export declare function nanmedian(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
 //# sourceMappingURL=reduction.d.ts.map

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

@@ -36,4 +36,109 @@ 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;
+/**
+ * Reverse the order of elements in an array along given axis
+ */
+export declare function flip(storage: ArrayStorage, axis?: number | number[]): ArrayStorage;
+/**
+ * Rotate array by 90 degrees in the plane specified by axes
+ */
+export declare function rot90(storage: ArrayStorage, k?: number, axes?: [number, number]): ArrayStorage;
+/**
+ * Roll array elements along a given axis
+ */
+export declare function roll(storage: ArrayStorage, shift: number | number[], axis?: number | number[]): ArrayStorage;
+/**
+ * Roll the specified axis backwards until it lies in a given position
+ */
+export declare function rollaxis(storage: ArrayStorage, axis: number, start?: number): ArrayStorage;
+/**
+ * Split array along third axis (depth)
+ */
+export declare function dsplit(storage: ArrayStorage, indicesOrSections: number | number[]): ArrayStorage[];
+/**
+ * Stack 1-D arrays as columns into a 2-D array
+ */
+export declare function columnStack(storages: ArrayStorage[]): ArrayStorage;
+/**
+ * Stack arrays in sequence vertically (row_stack is an alias for vstack)
+ */
+export declare const rowStack: typeof vstack;
+/**
+ * Resize array to new shape (returns new array, may repeat or truncate)
+ */
+export declare function resize(storage: ArrayStorage, newShape: number[]): ArrayStorage;
+/**
+ * Convert arrays to at least 1D
+ */
+export declare function atleast1d(storages: ArrayStorage[]): ArrayStorage[];
+/**
+ * Convert arrays to at least 2D
+ */
+export declare function atleast2d(storages: ArrayStorage[]): ArrayStorage[];
+/**
+ * Convert arrays to at least 3D
+ */
+export declare function atleast3d(storages: ArrayStorage[]): ArrayStorage[];
 //# sourceMappingURL=shape.d.ts.map

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

@@ -0,0 +1,110 @@
+/**
+ * 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;
+/**
+ * Convert angles from degrees to radians (alias for 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 deg2rad(a: ArrayStorage): ArrayStorage;
+/**
+ * Convert angles from radians to degrees (alias for 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 rad2deg(a: ArrayStorage): ArrayStorage;
+//# sourceMappingURL=trig.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "numpy-ts",
-  "version": "0.4.0",
+  "version": "0.6.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"
     }
   },
@@ -43,8 +54,10 @@
     "test:ci": "npm run lint && npm run typecheck && npm test && npm run test:bundles",
     "test:summary": "vitest run --reporter=tap | grep -E 'not ok|# tests'",
     "test:watch": "vitest watch",
-    "test:coverage": "vitest run tests/unit --coverage",
-    "test:coverage:view": "vitest run tests/unit --coverage; open coverage/index.html",
+    "test:coverage": "vitest run --project=unit --coverage",
+    "test:coverage:view": "vitest run --project=unit --coverage && open coverage/index.html",
+    "test:coverage:validation": "vitest run --project=validation-quick --coverage",
+    "test:coverage:validation:view": "vitest run --project=validation-quick --coverage && open coverage/index.html",
     "test:coverage:all": "vitest run --coverage",
     "lint": "eslint src tests --ext .ts",
     "lint:fix": "eslint src tests --ext .ts --fix",
@@ -57,7 +70,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 +95,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",
@@ -99,13 +113,12 @@
     "lint-staged": "^16.2.6",
     "playwright": "^1.56.1",
     "prettier": "^3.1.1",
-    "ts-node": "^10.9.2",
     "tsx": "^4.20.6",
     "typescript": "^5.3.3",
     "vitest": "^4.0.3"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20.1.0"
   },
   "overrides": {
     "js-yaml": ">=4.1.1"