numpy-ts 0.8.0 → 0.10.0

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

@@ -0,0 +1,201 @@
+/**
+ * Logic operations
+ *
+ * Pure functions for element-wise logical operations:
+ * logical_and, logical_or, logical_not, logical_xor,
+ * isfinite, isinf, isnan, isnat, copysign, signbit, nextafter, spacing
+ *
+ * These operations convert values to boolean (non-zero = true, zero = false)
+ * and return boolean arrays (dtype: 'bool').
+ */
+import { ArrayStorage } from '../core/storage';
+import { type DType } from '../core/dtype';
+/**
+ * Logical AND of two arrays or array and scalar
+ *
+ * Returns a boolean array where each element is the logical AND
+ * of corresponding elements (non-zero = true, zero = false).
+ *
+ * @param a - First array storage
+ * @param b - Second array storage or scalar
+ * @returns Boolean result storage
+ */
+export declare function logical_and(a: ArrayStorage, b: ArrayStorage | number): ArrayStorage;
+/**
+ * Logical OR of two arrays or array and scalar
+ *
+ * Returns a boolean array where each element is the logical OR
+ * of corresponding elements (non-zero = true, zero = false).
+ *
+ * @param a - First array storage
+ * @param b - Second array storage or scalar
+ * @returns Boolean result storage
+ */
+export declare function logical_or(a: ArrayStorage, b: ArrayStorage | number): ArrayStorage;
+/**
+ * Logical NOT of an array
+ *
+ * Returns a boolean array where each element is the logical NOT
+ * of the input (non-zero = false, zero = true).
+ *
+ * @param a - Input array storage
+ * @returns Boolean result storage
+ */
+export declare function logical_not(a: ArrayStorage): ArrayStorage;
+/**
+ * Logical XOR of two arrays or array and scalar
+ *
+ * Returns a boolean array where each element is the logical XOR
+ * of corresponding elements (non-zero = true, zero = false).
+ *
+ * @param a - First array storage
+ * @param b - Second array storage or scalar
+ * @returns Boolean result storage
+ */
+export declare function logical_xor(a: ArrayStorage, b: ArrayStorage | number): ArrayStorage;
+/**
+ * Test element-wise for finiteness (not infinity and not NaN)
+ *
+ * @param a - Input array storage
+ * @returns Boolean result storage
+ */
+export declare function isfinite(a: ArrayStorage): ArrayStorage;
+/**
+ * Test element-wise for positive or negative infinity
+ *
+ * @param a - Input array storage
+ * @returns Boolean result storage
+ */
+export declare function isinf(a: ArrayStorage): ArrayStorage;
+/**
+ * Test element-wise for NaN (Not a Number)
+ *
+ * @param a - Input array storage
+ * @returns Boolean result storage
+ */
+export declare function isnan(a: ArrayStorage): ArrayStorage;
+/**
+ * Test element-wise for NaT (Not a Time)
+ *
+ * In NumPy, NaT is the datetime equivalent of NaN.
+ * Since we don't have datetime support, this always returns false.
+ *
+ * @param a - Input array storage
+ * @returns Boolean result storage (all false)
+ */
+export declare function isnat(a: ArrayStorage): ArrayStorage;
+/**
+ * Change the sign of x1 to that of x2, element-wise
+ *
+ * Returns a value with the magnitude of x1 and the sign of x2.
+ *
+ * @param x1 - Values to change sign of (magnitude source)
+ * @param x2 - Values whose sign is used (sign source)
+ * @returns Array with magnitude from x1 and sign from x2
+ */
+export declare function copysign(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
+/**
+ * Returns element-wise True where signbit is set (less than zero)
+ *
+ * @param a - Input array storage
+ * @returns Boolean result storage
+ */
+export declare function signbit(a: ArrayStorage): ArrayStorage;
+/**
+ * Return the next floating-point value after x1 towards x2, element-wise
+ *
+ * @param x1 - Values to find the next representable value of
+ * @param x2 - Direction to look in for the next representable value
+ * @returns Array of next representable values
+ */
+export declare function nextafter(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
+/**
+ * Return the distance between x and the nearest adjacent number
+ *
+ * This is the difference between x and the next representable floating-point value.
+ *
+ * @param a - Input array storage
+ * @returns Array of spacing values
+ */
+export declare function spacing(a: ArrayStorage): ArrayStorage;
+/**
+ * Test element-wise for complex number
+ * Since numpy-ts doesn't support complex numbers, always returns false
+ * @param a - Input array storage
+ * @returns Boolean array (all false)
+ */
+export declare function iscomplex(a: ArrayStorage): ArrayStorage;
+/**
+ * Check whether object is complex type array
+ * Since numpy-ts doesn't support complex numbers, always returns false
+ * @param _a - Input array storage (unused)
+ * @returns false
+ */
+export declare function iscomplexobj(_a: ArrayStorage): boolean;
+/**
+ * Test element-wise for real number (not complex)
+ * Since numpy-ts doesn't support complex numbers, always returns true
+ * @param a - Input array storage
+ * @returns Boolean array (all true)
+ */
+export declare function isreal(a: ArrayStorage): ArrayStorage;
+/**
+ * Check whether object is real type array (not complex)
+ * Since numpy-ts doesn't support complex numbers, always returns true
+ * @param _a - Input array storage (unused)
+ * @returns true
+ */
+export declare function isrealobj(_a: ArrayStorage): boolean;
+/**
+ * Test element-wise for negative infinity
+ * @param a - Input array storage
+ * @returns Boolean array
+ */
+export declare function isneginf(a: ArrayStorage): ArrayStorage;
+/**
+ * Test element-wise for positive infinity
+ * @param a - Input array storage
+ * @returns Boolean array
+ */
+export declare function isposinf(a: ArrayStorage): ArrayStorage;
+/**
+ * Check if array is Fortran contiguous (column-major order)
+ * @param a - Input array storage
+ * @returns true if F-contiguous
+ */
+export declare function isfortran(a: ArrayStorage): boolean;
+/**
+ * Returns complex array with complex parts close to zero set to real
+ * Since numpy-ts doesn't support complex numbers, returns copy
+ * @param a - Input array storage
+ * @param _tol - Tolerance (unused, for API compatibility)
+ * @returns Copy of input array
+ */
+export declare function real_if_close(a: ArrayStorage, _tol?: number): ArrayStorage;
+/**
+ * Check if element is a scalar type
+ * @param val - Value to check
+ * @returns true if scalar
+ */
+export declare function isscalar(val: unknown): boolean;
+/**
+ * Check if object is iterable
+ * @param obj - Object to check
+ * @returns true if iterable
+ */
+export declare function iterable(obj: unknown): boolean;
+/**
+ * Check if dtype meets specified criteria
+ * @param dtype - Dtype to check
+ * @param kind - Kind of dtype ('b' bool, 'i' int, 'u' uint, 'f' float)
+ * @returns true if dtype matches kind
+ */
+export declare function isdtype(dtype: DType, kind: string): boolean;
+/**
+ * Find the dtype that can represent both input dtypes
+ * @param dtype1 - First dtype
+ * @param dtype2 - Second dtype
+ * @returns Promoted dtype
+ */
+export declare function promote_types(dtype1: DType, dtype2: DType): DType;
+//# sourceMappingURL=logic.d.ts.map

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/rounding.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Rounding operations
+ *
+ * Pure functions for element-wise rounding operations:
+ * around, ceil, fix, floor, rint, round, trunc
+ */
+import { ArrayStorage } from '../core/storage';
+/**
+ * Round an array to the given number of decimals
+ */
+export declare function around(a: ArrayStorage, decimals?: number): ArrayStorage;
+/**
+ * Return the ceiling of the input, element-wise
+ */
+export declare function ceil(a: ArrayStorage): ArrayStorage;
+/**
+ * Round to nearest integer towards zero
+ */
+export declare function fix(a: ArrayStorage): ArrayStorage;
+/**
+ * Return the floor of the input, element-wise
+ */
+export declare function floor(a: ArrayStorage): ArrayStorage;
+/**
+ * Round elements of the array to the nearest integer (banker's rounding)
+ */
+export declare function rint(a: ArrayStorage): ArrayStorage;
+/**
+ * Alias for around
+ */
+export declare function round(a: ArrayStorage, decimals?: number): ArrayStorage;
+/**
+ * Return the truncated value of the input, element-wise
+ */
+export declare function trunc(a: ArrayStorage): ArrayStorage;
+//# sourceMappingURL=rounding.d.ts.map

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

@@ -0,0 +1,38 @@
+/**
+ * Set operations
+ */
+import { ArrayStorage } from '../core/storage';
+/**
+ * Find the unique elements of an array
+ */
+export declare function unique(a: ArrayStorage, returnIndex?: boolean, returnInverse?: boolean, returnCounts?: boolean): ArrayStorage | {
+    values: ArrayStorage;
+    indices?: ArrayStorage;
+    inverse?: ArrayStorage;
+    counts?: ArrayStorage;
+};
+/**
+ * Test whether each element of a 1-D array is also present in a second array
+ */
+export declare function in1d(ar1: ArrayStorage, ar2: ArrayStorage): ArrayStorage;
+/**
+ * Find the intersection of two arrays
+ */
+export declare function intersect1d(ar1: ArrayStorage, ar2: ArrayStorage): ArrayStorage;
+/**
+ * Test whether each element of an ND array is also present in a second array
+ */
+export declare function isin(element: ArrayStorage, testElements: ArrayStorage): ArrayStorage;
+/**
+ * Find the set difference of two arrays
+ */
+export declare function setdiff1d(ar1: ArrayStorage, ar2: ArrayStorage): ArrayStorage;
+/**
+ * Find the set exclusive-or of two arrays
+ */
+export declare function setxor1d(ar1: ArrayStorage, ar2: ArrayStorage): ArrayStorage;
+/**
+ * Find the union of two arrays
+ */
+export declare function union1d(ar1: ArrayStorage, ar2: ArrayStorage): ArrayStorage;
+//# sourceMappingURL=sets.d.ts.map

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "numpy-ts",
-  "version": "0.8.0",
+  "version": "0.10.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"