numpy-ts 0.9.0 → 0.11.0

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

@@ -0,0 +1,136 @@
+/**
+ * Random number generation module
+ *
+ * Implements NumPy-compatible random functions:
+ * - Legacy API (np.random.seed, random, rand, uniform, etc.) uses MT19937
+ * - Modern API (np.random.default_rng) uses PCG64 with SeedSequence
+ *
+ * Both implementations produce identical output to NumPy when seeded.
+ */
+import { ArrayStorage } from '../core/storage';
+import { type DType } from '../core/dtype';
+/**
+ * Random number generator class (matches NumPy's Generator from default_rng)
+ */
+export declare class Generator {
+    private _pcgState;
+    constructor(seedValue?: number);
+    private _randomFloat;
+    random(size?: number | number[]): ArrayStorage | number;
+    integers(low: number, high?: number, size?: number | number[]): ArrayStorage | number;
+    standard_normal(size?: number | number[]): ArrayStorage | number;
+    normal(loc?: number, scale?: number, size?: number | number[]): ArrayStorage | number;
+    uniform(low?: number, high?: number, size?: number | number[]): ArrayStorage | number;
+    choice(a: number | ArrayStorage, size?: number | number[], replace?: boolean, p?: ArrayStorage | number[]): ArrayStorage | number;
+    permutation(x: number | ArrayStorage): ArrayStorage;
+    shuffle(x: ArrayStorage): void;
+    exponential(scale?: number, size?: number | number[]): ArrayStorage | number;
+    poisson(lam?: number, size?: number | number[]): ArrayStorage | number;
+    binomial(n: number, p: number, size?: number | number[]): ArrayStorage | number;
+}
+/**
+ * Create a new Generator instance (matches np.random.default_rng)
+ * @param seedValue - Optional seed value
+ */
+export declare function default_rng(seedValue?: number): Generator;
+/**
+ * Seed the random number generator (legacy API)
+ * @param seedValue - Seed value (integer)
+ */
+export declare function seed(seedValue?: number | null): void;
+/**
+ * Get the internal state of the random number generator
+ * @returns State object that can be used with set_state
+ */
+export declare function get_state(): {
+    mt: number[];
+    mti: number;
+};
+/**
+ * Set the internal state of the random number generator
+ * @param state - State object from get_state
+ */
+export declare function set_state(state: {
+    mt: number[];
+    mti: number;
+}): void;
+/**
+ * Generate random floats in the half-open interval [0.0, 1.0)
+ * @param size - Output shape. If not provided, returns a single float.
+ */
+export declare function random(size?: number | number[]): ArrayStorage | number;
+/**
+ * Random values in a given shape (alias for random with shape)
+ * @param d0, d1, ..., dn - The dimensions of the returned array
+ */
+export declare function rand(...shape: number[]): ArrayStorage | number;
+/**
+ * Return random floats from standard normal distribution
+ * @param d0, d1, ..., dn - The dimensions of the returned array
+ */
+export declare function randn(...shape: number[]): ArrayStorage | number;
+/**
+ * Return random integers from low (inclusive) to high (exclusive)
+ * @param low - Lowest integer (or high if high is not provided)
+ * @param high - One above the highest integer (optional)
+ * @param size - Output shape
+ * @param dtype - Output dtype (default 'int64')
+ */
+export declare function randint(low: number, high?: number | null, size?: number | number[], dtype?: DType): ArrayStorage | number;
+/**
+ * Draw samples from a uniform distribution
+ * @param low - Lower boundary (default 0)
+ * @param high - Upper boundary (default 1)
+ * @param size - Output shape
+ */
+export declare function uniform(low?: number, high?: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a normal (Gaussian) distribution
+ * @param loc - Mean of the distribution (default 0)
+ * @param scale - Standard deviation (default 1)
+ * @param size - Output shape
+ */
+export declare function normal(loc?: number, scale?: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a standard normal distribution (mean=0, std=1)
+ * @param size - Output shape
+ */
+export declare function standard_normal(size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from an exponential distribution
+ * @param scale - The scale parameter (beta = 1/lambda) (default 1)
+ * @param size - Output shape
+ */
+export declare function exponential(scale?: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a Poisson distribution
+ * @param lam - Expected number of events (lambda) (default 1)
+ * @param size - Output shape
+ */
+export declare function poisson(lam?: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a binomial distribution
+ * @param n - Number of trials
+ * @param p - Probability of success
+ * @param size - Output shape
+ */
+export declare function binomial(n: number, p: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Generate a random sample from a given 1-D array
+ * @param a - Input array or int. If int, samples from arange(a)
+ * @param size - Output shape
+ * @param replace - Whether sampling with replacement (default true)
+ * @param p - Probabilities associated with each entry
+ */
+export declare function choice(a: number | ArrayStorage, size?: number | number[], replace?: boolean, p?: ArrayStorage | number[]): ArrayStorage | number;
+/**
+ * Randomly permute a sequence, or return a permuted range
+ * @param x - Input array or int. If int, returns permutation of arange(x)
+ */
+export declare function permutation(x: number | ArrayStorage): ArrayStorage;
+/**
+ * Modify a sequence in-place by shuffling its contents
+ * @param x - Array to be shuffled
+ */
+export declare function shuffle(x: ArrayStorage): void;
+//# sourceMappingURL=random.d.ts.map

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

@@ -5,30 +5,29 @@
  * @module ops/reduction
  */
 import { ArrayStorage } from '../core/storage';
+import { Complex } from '../core/complex';
 /**
  * Sum array elements over a given axis
  */
-export declare function sum(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
+export declare function sum(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number | Complex;
 /**
  * Compute the arithmetic mean along the specified axis
  * Note: mean() returns float64 for integer dtypes, matching NumPy behavior
+ * For complex arrays, returns complex mean
  */
-export declare function mean(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
+export declare function mean(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number | Complex;
 /**
  * Return the maximum along a given axis
  */
-export declare function max(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
+export declare function max(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number | Complex;
 /**
  * Product array elements over a given axis
  */
-export declare function prod(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
+export declare function prod(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number | Complex;
 /**
  * Return the minimum along a given axis
  */
-export declare function min(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
-/**
- * Return the indices of the minimum values along a given axis
- */
+export declare function min(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number | Complex;
 export declare function argmin(storage: ArrayStorage, axis?: number): ArrayStorage | number;
 /**
  * Return the indices of the maximum values along a given axis
@@ -40,6 +39,9 @@ export declare function argmax(storage: ArrayStorage, axis?: number): ArrayStora
  * @param axis - Axis along which to compute variance
  * @param ddof - Delta degrees of freedom (default: 0)
  * @param keepdims - Keep dimensions (default: false)
+ *
+ * For complex arrays: Var(X) = E[|X - E[X]|²] where |z|² = re² + im²
+ * Returns real values (float64) for both real and complex input
  */
 export declare function variance(storage: ArrayStorage, axis?: number, ddof?: number, keepdims?: boolean): ArrayStorage | number;
 /**
@@ -48,6 +50,9 @@ export declare function variance(storage: ArrayStorage, axis?: number, ddof?: nu
  * @param axis - Axis along which to compute std
  * @param ddof - Delta degrees of freedom (default: 0)
  * @param keepdims - Keep dimensions (default: false)
+ *
+ * For complex arrays: returns sqrt(Var(X)) where Var(X) = E[|X - E[X]|²]
+ * Returns real values (float64) for both real and complex input
  */
 export declare function std(storage: ArrayStorage, axis?: number, ddof?: number, keepdims?: boolean): ArrayStorage | number;
 /**
@@ -60,16 +65,19 @@ export declare function all(storage: ArrayStorage, axis?: number, keepdims?: boo
 export declare function any(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | boolean;
 /**
  * Return cumulative sum of elements along a given axis
+ * For complex arrays: returns complex cumulative sum
  */
 export declare function cumsum(storage: ArrayStorage, axis?: number): ArrayStorage;
 /**
  * Return cumulative product of elements along a given axis
+ * For complex arrays: returns complex cumulative product
+ * Complex multiplication: (a+bi)(c+di) = (ac-bd) + (ad+bc)i
  */
 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;
+export declare function ptp(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number | Complex;
 /**
  * Compute the median along the specified axis
  */
@@ -85,41 +93,40 @@ export declare function quantile(storage: ArrayStorage, q: number, axis?: 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;
+export declare function average(storage: ArrayStorage, axis?: number, weights?: ArrayStorage, keepdims?: boolean): ArrayStorage | number | Complex;
+export declare function nansum(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number | Complex;
 /**
  * Return product of elements, treating NaNs as one
  */
-export declare function nanprod(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
+export declare function nanprod(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number | Complex;
 /**
  * Compute mean ignoring NaN values
  */
-export declare function nanmean(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
+export declare function nanmean(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number | Complex;
 /**
  * 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
+ * For complex arrays: returns sqrt of variance (always real 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;
+export declare function nanmin(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number | Complex;
 /**
  * Return maximum ignoring NaN values
  */
-export declare function nanmax(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
+export declare function nanmax(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number | Complex;
 /**
  * Return indices of minimum value, ignoring NaNs
  */
 export declare function nanargmin(storage: ArrayStorage, axis?: number): ArrayStorage | number;
 /**
  * Return indices of maximum value, ignoring NaNs
+ * For complex arrays: uses lexicographic ordering (real first, then imaginary)
  */
 export declare function nanargmax(storage: ArrayStorage, axis?: number): ArrayStorage | number;
 /**
@@ -128,6 +135,7 @@ export declare function nanargmax(storage: ArrayStorage, axis?: number): ArraySt
 export declare function nancumsum(storage: ArrayStorage, axis?: number): ArrayStorage;
 /**
  * Return cumulative product, treating NaNs as one
+ * For complex arrays: NaN values (either part NaN) are treated as 1+0i
  */
 export declare function nancumprod(storage: ArrayStorage, axis?: number): ArrayStorage;
 /**

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

@@ -3,6 +3,9 @@
  *
  * Pure functions for element-wise rounding operations:
  * around, ceil, fix, floor, rint, round, trunc
+ *
+ * Note: Rounding operations are not defined for complex numbers.
+ * All functions throw TypeError for complex dtypes.
  */
 import { ArrayStorage } from '../core/storage';
 /**

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

@@ -56,6 +56,14 @@ export declare function sort_complex(storage: ArrayStorage): ArrayStorage;
  * @returns Tuple of arrays, one for each dimension
  */
 export declare function nonzero(storage: ArrayStorage): ArrayStorage[];
+/**
+ * Find the indices of array elements that are non-zero, grouped by element
+ * Returns a 2D array where each row is the index of a non-zero element.
+ * This is equivalent to transpose(nonzero(a)).
+ * @param storage - Input array storage
+ * @returns 2D array of shape (N, ndim) where N is number of non-zero elements
+ */
+export declare function argwhere(storage: ArrayStorage): ArrayStorage;
 /**
  * Return indices of non-zero elements in flattened array
  * @param storage - Input array storage

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

@@ -0,0 +1,108 @@
+/**
+ * Statistics operations (histogram, bincount, correlate, cov, etc.)
+ *
+ * Pure functions for statistical analysis.
+ * @module ops/statistics
+ */
+import { ArrayStorage } from '../core/storage';
+/**
+ * Count number of occurrences of each value in array of non-negative ints.
+ *
+ * @param x - Input array (must contain non-negative integers)
+ * @param weights - Optional weights, same shape as x
+ * @param minlength - Minimum number of bins for output (default: 0)
+ * @returns Array of bin counts
+ */
+export declare function bincount(x: ArrayStorage, weights?: ArrayStorage, minlength?: number): ArrayStorage;
+/**
+ * Return the indices of the bins to which each value in input array belongs.
+ *
+ * @param x - Input array to be binned
+ * @param bins - Array of bins (monotonically increasing or decreasing)
+ * @param right - If true, intervals are closed on the right (default: false)
+ * @returns Array of bin indices
+ */
+export declare function digitize(x: ArrayStorage, bins: ArrayStorage, right?: boolean): ArrayStorage;
+/**
+ * Compute the histogram of a set of data.
+ *
+ * @param a - Input data (flattened if not 1D)
+ * @param bins - Number of bins (default: 10) or array of bin edges
+ * @param range - Lower and upper range of bins. If not provided, uses [a.min(), a.max()]
+ * @param density - If true, return probability density function (default: false)
+ * @param weights - Optional weights for each data point
+ * @returns Tuple of [hist, bin_edges]
+ */
+export declare function histogram(a: ArrayStorage, bins?: number | ArrayStorage, range?: [number, number], density?: boolean, weights?: ArrayStorage): {
+    hist: ArrayStorage;
+    bin_edges: ArrayStorage;
+};
+/**
+ * Compute the bi-dimensional histogram of two data samples.
+ *
+ * @param x - Array of x coordinates
+ * @param y - Array of y coordinates (must have same length as x)
+ * @param bins - Number of bins or [nx, ny] or [x_edges, y_edges]
+ * @param range - [[xmin, xmax], [ymin, ymax]]
+ * @param density - If true, return probability density function
+ * @param weights - Optional weights for each data point
+ * @returns Object with hist, x_edges, y_edges
+ */
+export declare function histogram2d(x: ArrayStorage, y: ArrayStorage, bins?: number | [number, number] | [ArrayStorage, ArrayStorage], range?: [[number, number], [number, number]], density?: boolean, weights?: ArrayStorage): {
+    hist: ArrayStorage;
+    x_edges: ArrayStorage;
+    y_edges: ArrayStorage;
+};
+/**
+ * Compute the multidimensional histogram of some data.
+ *
+ * @param sample - Array of shape (N, D) where N is number of samples and D is number of dimensions
+ * @param bins - Number of bins for all axes, or array of bin counts per axis
+ * @param range - Array of [min, max] for each dimension
+ * @param density - If true, return probability density function
+ * @param weights - Optional weights for each sample
+ * @returns Object with hist and edges (array of edge arrays)
+ */
+export declare function histogramdd(sample: ArrayStorage, bins?: number | number[], range?: [number, number][], density?: boolean, weights?: ArrayStorage): {
+    hist: ArrayStorage;
+    edges: ArrayStorage[];
+};
+/**
+ * Cross-correlation of two 1-dimensional sequences.
+ *
+ * @param a - First input sequence
+ * @param v - Second input sequence
+ * @param mode - 'full', 'same', or 'valid' (default: 'full')
+ * @returns Cross-correlation of a and v
+ */
+export declare function correlate(a: ArrayStorage, v: ArrayStorage, mode?: 'full' | 'same' | 'valid'): ArrayStorage;
+/**
+ * Discrete, linear convolution of two one-dimensional sequences.
+ *
+ * @param a - First input sequence
+ * @param v - Second input sequence
+ * @param mode - 'full', 'same', or 'valid' (default: 'full')
+ * @returns Convolution of a and v
+ */
+export declare function convolve(a: ArrayStorage, v: ArrayStorage, mode?: 'full' | 'same' | 'valid'): ArrayStorage;
+/**
+ * Estimate a covariance matrix.
+ *
+ * @param m - Input array (1D or 2D). Each row represents a variable, columns are observations.
+ * @param y - Optional second array (for 2 variable case)
+ * @param rowvar - If true, each row is a variable (default: true)
+ * @param bias - If true, use N for normalization; if false, use N-1 (default: false)
+ * @param ddof - Delta degrees of freedom (overrides bias if provided)
+ * @returns Covariance matrix
+ */
+export declare function cov(m: ArrayStorage, y?: ArrayStorage, rowvar?: boolean, bias?: boolean, ddof?: number): ArrayStorage;
+/**
+ * Return Pearson product-moment correlation coefficients.
+ *
+ * @param x - Input array (1D or 2D)
+ * @param y - Optional second array (for 2 variable case)
+ * @param rowvar - If true, each row is a variable (default: true)
+ * @returns Correlation coefficient matrix
+ */
+export declare function corrcoef(x: ArrayStorage, y?: ArrayStorage, rowvar?: boolean): ArrayStorage;
+//# sourceMappingURL=statistics.d.ts.map

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

@@ -11,6 +11,7 @@ import { ArrayStorage } from '../core/storage';
 /**
  * Sine of each element (element-wise)
  * NumPy behavior: Always promotes to float64 for integer types
+ * For complex: sin(a+bi) = sin(a)cosh(b) + i*cos(a)sinh(b)
  *
  * @param a - Input array storage (angles in radians)
  * @returns Result storage with sin applied
@@ -19,6 +20,7 @@ export declare function sin(a: ArrayStorage): ArrayStorage;
 /**
  * Cosine of each element (element-wise)
  * NumPy behavior: Always promotes to float64 for integer types
+ * For complex: cos(a+bi) = cos(a)cosh(b) - i*sin(a)sinh(b)
  *
  * @param a - Input array storage (angles in radians)
  * @returns Result storage with cos applied
@@ -27,6 +29,7 @@ export declare function cos(a: ArrayStorage): ArrayStorage;
 /**
  * Tangent of each element (element-wise)
  * NumPy behavior: Always promotes to float64 for integer types
+ * For complex: tan(a+bi) = (sin(2a) + i*sinh(2b)) / (cos(2a) + cosh(2b))
  *
  * @param a - Input array storage (angles in radians)
  * @returns Result storage with tan applied
@@ -35,6 +38,7 @@ export declare function tan(a: ArrayStorage): ArrayStorage;
 /**
  * Inverse sine of each element (element-wise)
  * NumPy behavior: Always promotes to float64 for integer types
+ * For complex: arcsin(z) = -i * log(iz + sqrt(1 - z²))
  *
  * @param a - Input array storage (values in range [-1, 1])
  * @returns Result storage with arcsin applied (radians)
@@ -43,6 +47,7 @@ export declare function arcsin(a: ArrayStorage): ArrayStorage;
 /**
  * Inverse cosine of each element (element-wise)
  * NumPy behavior: Always promotes to float64 for integer types
+ * For complex: arccos(z) = -i * log(z + i*sqrt(1 - z²))
  *
  * @param a - Input array storage (values in range [-1, 1])
  * @returns Result storage with arccos applied (radians)
@@ -51,6 +56,7 @@ export declare function arccos(a: ArrayStorage): ArrayStorage;
 /**
  * Inverse tangent of each element (element-wise)
  * NumPy behavior: Always promotes to float64 for integer types
+ * For complex: arctan(z) = (i/2) * log((1 - iz) / (1 + iz))
  *
  * @param a - Input array storage
  * @returns Result storage with arctan applied (radians)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "numpy-ts",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "Complete NumPy implementation for TypeScript and JavaScript (under construction)",
   "main": "dist/numpy-ts.node.cjs",
   "browser": "dist/numpy-ts.browser.js",
@@ -90,7 +90,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/dupontcyborg/numpy-ts.git"
+    "url": "git+https://github.com/dupontcyborg/numpy-ts.git"
   },
   "bugs": {
     "url": "https://github.com/dupontcyborg/numpy-ts/issues"