numpy-ts 0.5.0 → 0.6.0

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, sqrt, power, absolute, negative, sign, mod, floor_divide, positive, reciprocal, dot, trace, transpose, inner, outer, tensordot, sin, cos, tan, arcsin, arccos, arctan, arctan2, hypot, degrees, radians, sinh, cosh, tanh, arcsinh, arccosh, arctanh, swapaxes, moveaxis, concatenate, stack, vstack, hstack, dstack, split, array_split, vsplit, hsplit, tile, repeat, broadcast_to, broadcast_arrays, take, put, choose, array_equal, } 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, cumsum, cumprod, ptp, median, percentile, quantile, average, nansum, nanprod, nanmean, nanvar, nanstd, nanmin, nanmax, nanargmin, nanargmax, nancumsum, nancumprod, nanmedian, } 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/ops/advanced.d.ts

@@ -5,6 +5,7 @@
  * @module ops/advanced
  */
 import { ArrayStorage } from '../core/storage';
+import { broadcastShapes } from '../core/broadcasting';
 /**
  * Broadcast an array to a given shape
  * Returns a read-only view on the original array
@@ -15,6 +16,11 @@ export declare function broadcast_to(storage: ArrayStorage, targetShape: number[
  * Returns views on the original arrays
  */
 export declare function broadcast_arrays(storages: ArrayStorage[]): ArrayStorage[];
+/**
+ * Compute the broadcast shape for multiple shapes
+ * Re-export from core/broadcasting for convenience
+ */
+export { broadcastShapes as broadcast_shapes };
 /**
  * Take elements from an array along an axis
  */

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

@@ -105,4 +105,58 @@ export declare function positive(a: ArrayStorage): ArrayStorage;
  * @returns Result storage with reciprocal values
  */
 export declare function reciprocal(a: ArrayStorage): ArrayStorage;
+/**
+ * Cube root of each element
+ * NumPy behavior: Promotes integer types to float64
+ *
+ * @param a - Input array storage
+ * @returns Result storage with cube root values
+ */
+export declare function cbrt(a: ArrayStorage): ArrayStorage;
+/**
+ * Absolute value of each element, returning float
+ * NumPy behavior: fabs always returns floating point
+ *
+ * @param a - Input array storage
+ * @returns Result storage with absolute values as float
+ */
+export declare function fabs(a: ArrayStorage): ArrayStorage;
+/**
+ * Returns both quotient and remainder (floor divide and modulo)
+ * NumPy behavior: divmod(a, b) = (floor_divide(a, b), mod(a, b))
+ *
+ * @param a - Dividend array storage
+ * @param b - Divisor (array storage or scalar)
+ * @returns Tuple of [quotient, remainder] storages
+ */
+export declare function divmod(a: ArrayStorage, b: ArrayStorage | number): [ArrayStorage, ArrayStorage];
+/**
+ * Element-wise square of each element
+ * NumPy behavior: x**2
+ *
+ * @param a - Input array storage
+ * @returns Result storage with squared values
+ */
+export declare function square(a: ArrayStorage): ArrayStorage;
+/**
+ * Remainder of division (same as mod)
+ * NumPy behavior: Same as mod, alias for compatibility
+ *
+ * @param a - Dividend array storage
+ * @param b - Divisor (array storage or scalar)
+ * @returns Result storage with remainder values
+ */
+export declare function remainder(a: ArrayStorage, b: ArrayStorage | number): ArrayStorage;
+/**
+ * Heaviside step function
+ * NumPy behavior:
+ *   heaviside(x1, x2) = 0 if x1 < 0
+ *                     = x2 if x1 == 0
+ *                     = 1 if x1 > 0
+ *
+ * @param x1 - Input array storage
+ * @param x2 - Value to use when x1 == 0 (array storage or scalar)
+ * @returns Result storage with heaviside values
+ */
+export declare function heaviside(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
 //# sourceMappingURL=arithmetic.d.ts.map

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/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

@@ -97,4 +97,48 @@ export declare function tile(storage: ArrayStorage, reps: number | number[]): Ar
  * 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

@@ -91,4 +91,20 @@ export declare function degrees(a: ArrayStorage): ArrayStorage;
  * @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.5.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",
@@ -54,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",
@@ -111,7 +113,6 @@
     "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"