numpy-ts 0.1.0 → 0.2.0

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

@@ -97,6 +97,37 @@ export declare class NDArray {
     subtract(other: NDArray | number): NDArray;
     multiply(other: NDArray | number): NDArray;
     divide(other: NDArray | number): NDArray;
+    mod(other: NDArray | number): NDArray;
+    floor_divide(other: NDArray | number): NDArray;
+    positive(): NDArray;
+    reciprocal(): NDArray;
+    /**
+     * Square root of each element
+     * Promotes integer types to float64
+     * @returns New array with square roots
+     */
+    sqrt(): NDArray;
+    /**
+     * Raise elements to power
+     * @param exponent - Power to raise to (array or scalar)
+     * @returns New array with powered values
+     */
+    power(exponent: NDArray | number): NDArray;
+    /**
+     * Absolute value of each element
+     * @returns New array with absolute values
+     */
+    absolute(): NDArray;
+    /**
+     * Numerical negative (element-wise negation)
+     * @returns New array with negated values
+     */
+    negative(): NDArray;
+    /**
+     * Sign of each element (-1, 0, or 1)
+     * @returns New array with signs
+     */
+    sign(): NDArray;
     /**
      * Element-wise greater than comparison
      * @param other - Value or array to compare with
@@ -318,9 +349,6 @@ export declare function zeros(shape: number[], dtype?: DType): NDArray;
  * Create array of ones
  */
 export declare function ones(shape: number[], dtype?: DType): NDArray;
-/**
- * Create array from nested JavaScript arrays
- */
 export declare function array(data: any, dtype?: DType): NDArray;
 /**
  * Create array with evenly spaced values within a given interval
@@ -383,5 +411,14 @@ export declare function empty_like(a: NDArray, dtype?: DType): NDArray;
  * Create array filled with a constant value, same shape as another array
  */
 export declare function full_like(a: NDArray, fill_value: number | bigint | boolean, dtype?: DType): NDArray;
+export declare function sqrt(x: NDArray): NDArray;
+export declare function power(x: NDArray, exponent: NDArray | number): NDArray;
+export declare function absolute(x: NDArray): NDArray;
+export declare function negative(x: NDArray): NDArray;
+export declare function sign(x: NDArray): NDArray;
+export declare function mod(x: NDArray, divisor: NDArray | number): NDArray;
+export declare function floor_divide(x: NDArray, divisor: NDArray | number): NDArray;
+export declare function positive(x: NDArray): NDArray;
+export declare function reciprocal(x: NDArray): NDArray;
 export {};
 //# sourceMappingURL=ndarray.d.ts.map

package/dist/types/index.d.ts

@@ -3,6 +3,6 @@
  *
  * @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, } 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, sqrt, power, absolute, negative, sign, mod, floor_divide, positive, reciprocal, } from './core/ndarray';
 export declare const __version__: string;
 //# sourceMappingURL=index.d.ts.map

package/dist/types/internal/compute.d.ts

@@ -22,4 +22,13 @@ export declare function elementwiseBinaryOp(a: ArrayStorage, b: ArrayStorage, op
  * Returns boolean array (dtype: 'bool', stored as Uint8Array)
  */
 export declare function elementwiseComparisonOp(a: ArrayStorage, b: ArrayStorage, op: (a: number, b: number) => boolean): ArrayStorage;
+/**
+ * Perform element-wise unary operation
+ *
+ * @param a - Input array storage
+ * @param op - Operation to perform (x) => result
+ * @param preserveDtype - If true, preserve input dtype; if false, promote to float64 (default: true)
+ * @returns Result storage
+ */
+export declare function elementwiseUnaryOp(a: ArrayStorage, op: (x: number) => number, preserveDtype?: boolean): ArrayStorage;
 //# sourceMappingURL=compute.d.ts.map

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

@@ -46,4 +46,63 @@ export declare function multiply(a: ArrayStorage, b: ArrayStorage | number): Arr
  * @returns Result storage with promoted float dtype
  */
 export declare function divide(a: ArrayStorage, b: ArrayStorage | number): ArrayStorage;
+/**
+ * Absolute value of each element
+ * Preserves dtype
+ *
+ * @param a - Input array storage
+ * @returns Result storage with absolute values
+ */
+export declare function absolute(a: ArrayStorage): ArrayStorage;
+/**
+ * Numerical negative (element-wise negation)
+ * Preserves dtype
+ *
+ * @param a - Input array storage
+ * @returns Result storage with negated values
+ */
+export declare function negative(a: ArrayStorage): ArrayStorage;
+/**
+ * Sign of each element (-1, 0, or 1)
+ * Preserves dtype
+ *
+ * @param a - Input array storage
+ * @returns Result storage with signs
+ */
+export declare function sign(a: ArrayStorage): ArrayStorage;
+/**
+ * Modulo operation (remainder after division)
+ * NumPy behavior: Uses floor modulo (sign follows divisor), not JavaScript's truncate modulo
+ * Preserves dtype for integer types
+ *
+ * @param a - Dividend array storage
+ * @param b - Divisor (array storage or scalar)
+ * @returns Result storage with modulo values
+ */
+export declare function mod(a: ArrayStorage, b: ArrayStorage | number): ArrayStorage;
+/**
+ * Floor division (division with result rounded down)
+ * NumPy behavior: Preserves integer types
+ *
+ * @param a - Dividend array storage
+ * @param b - Divisor (array storage or scalar)
+ * @returns Result storage with floor division values
+ */
+export declare function floorDivide(a: ArrayStorage, b: ArrayStorage | number): ArrayStorage;
+/**
+ * Unary positive (returns a copy of the array)
+ * Preserves dtype
+ *
+ * @param a - Input array storage
+ * @returns Result storage (copy of input)
+ */
+export declare function positive(a: ArrayStorage): ArrayStorage;
+/**
+ * Reciprocal (1/x) of each element
+ * NumPy behavior: Always promotes to float64 for integer types
+ *
+ * @param a - Input array storage
+ * @returns Result storage with reciprocal values
+ */
+export declare function reciprocal(a: ArrayStorage): ArrayStorage;
 //# sourceMappingURL=arithmetic.d.ts.map

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

@@ -0,0 +1,28 @@
+/**
+ * Exponential, logarithmic, and power operations
+ *
+ * Pure functions for element-wise exponential operations:
+ * exp, log, sqrt, power, etc.
+ *
+ * These functions are used by NDArray methods but are separated
+ * to keep the codebase modular and testable.
+ */
+import { ArrayStorage } from '../core/storage';
+/**
+ * Square root of each element
+ * NumPy behavior: Always promotes to float64 for integer types
+ *
+ * @param a - Input array storage
+ * @returns Result storage with sqrt applied
+ */
+export declare function sqrt(a: ArrayStorage): ArrayStorage;
+/**
+ * Raise elements to power
+ * NumPy behavior: Promotes to float64 for integer types with non-integer exponents
+ *
+ * @param a - Base array storage
+ * @param b - Exponent (array storage or scalar)
+ * @returns Result storage with power applied
+ */
+export declare function power(a: ArrayStorage, b: ArrayStorage | number): ArrayStorage;
+//# sourceMappingURL=exponential.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "numpy-ts",
-  "version": "0.1.0",
+  "version": "0.2.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,6 @@
     "bench:build": "esbuild benchmarks/src/index.ts --bundle --platform=node --format=cjs --outfile=benchmarks/dist/bench.cjs",
     "bench": "npm run bench:build && node benchmarks/dist/bench.cjs",
     "bench:quick": "npm run bench:build && node benchmarks/dist/bench.cjs --quick",
-    "bench:standard": "npm run bench:build && node benchmarks/dist/bench.cjs --standard",
-    "bench:full": "npm run bench:build && node benchmarks/dist/bench.cjs --full",
     "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"
   },