numpy-ts 0.11.0 → 0.13.0

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

@@ -0,0 +1,50 @@
+/**
+ * Polynomial functions
+ *
+ * Tree-shakeable standalone functions for polynomial operations.
+ */
+import { NDArrayCore } from '../common/ndarray-core';
+/**
+ * Find the coefficients of a polynomial with given roots
+ */
+export declare function poly(seq_of_zeros: NDArrayCore | number[]): NDArrayCore;
+/**
+ * Add two polynomials
+ */
+export declare function polyadd(a1: NDArrayCore | number[], a2: NDArrayCore | number[]): NDArrayCore;
+/**
+ * Differentiate a polynomial
+ */
+export declare function polyder(p: NDArrayCore | number[], m?: number): NDArrayCore;
+/**
+ * Divide two polynomials
+ */
+export declare function polydiv(u: NDArrayCore | number[], v: NDArrayCore | number[]): [NDArrayCore, NDArrayCore];
+/**
+ * Least squares polynomial fit
+ */
+export declare function polyfit(x: NDArrayCore, y: NDArrayCore, deg: number): NDArrayCore;
+/**
+ * Integrate a polynomial
+ */
+export declare function polyint(p: NDArrayCore | number[], m?: number, k?: number | number[]): NDArrayCore;
+/**
+ * Multiply two polynomials
+ */
+export declare function polymul(a1: NDArrayCore | number[], a2: NDArrayCore | number[]): NDArrayCore;
+/**
+ * Subtract two polynomials
+ */
+export declare function polysub(a1: NDArrayCore | number[], a2: NDArrayCore | number[]): NDArrayCore;
+/**
+ * Evaluate a polynomial at given points
+ */
+export declare function polyval(p: NDArrayCore | number[], x: NDArrayCore | number | number[]): NDArrayCore | number;
+/**
+ * Find the roots of a polynomial.
+ *
+ * Uses the companion matrix eigenvalue method (same as NumPy).
+ * Always returns a complex128 NDArrayCore.
+ */
+export declare function roots(p: NDArrayCore | number[]): NDArrayCore;
+//# sourceMappingURL=polynomial.d.ts.map

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

@@ -0,0 +1,82 @@
+/**
+ * Reduction Functions - Tree-shakeable standalone functions
+ *
+ * This module provides array reduction and aggregation functions that can be
+ * imported independently for optimal tree-shaking.
+ */
+import { NDArrayCore, Complex } from './types';
+/** Sum of array elements */
+export declare function sum(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArrayCore | number | bigint | Complex;
+/** Mean of array elements */
+export declare function mean(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArrayCore | number | Complex;
+/** Product of array elements */
+export declare function prod(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArrayCore | number | bigint | Complex;
+/** Maximum of array elements */
+export declare function max(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArrayCore | number | Complex;
+/** Alias for max */
+export declare const amax: typeof max;
+/** Minimum of array elements */
+export declare function min(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArrayCore | number | Complex;
+/** Alias for min */
+export declare const amin: typeof min;
+/** Peak-to-peak (max - min) */
+export declare function ptp(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArrayCore | number | Complex;
+/** Index of minimum value */
+export declare function argmin(a: NDArrayCore, axis?: number): NDArrayCore | number;
+/** Index of maximum value */
+export declare function argmax(a: NDArrayCore, axis?: number): NDArrayCore | number;
+/** Variance of array elements */
+export declare function variance(a: NDArrayCore, axis?: number, ddof?: number, keepdims?: boolean): NDArrayCore | number;
+/** Alias for variance */
+export declare const var_: typeof variance;
+/** Standard deviation of array elements */
+export declare function std(a: NDArrayCore, axis?: number, ddof?: number, keepdims?: boolean): NDArrayCore | number;
+/** Median of array elements */
+export declare function median(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArrayCore | number;
+/** Percentile of array elements */
+export declare function percentile(a: NDArrayCore, q: number, axis?: number, keepdims?: boolean): NDArrayCore | number;
+/** Quantile of array elements */
+export declare function quantile(a: NDArrayCore, q: number, axis?: number, keepdims?: boolean): NDArrayCore | number;
+/** Weighted average */
+export declare function average(a: NDArrayCore, axis?: number, weights?: NDArrayCore, keepdims?: boolean): NDArrayCore | number | Complex;
+/** Test if all elements are true */
+export declare function all(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArrayCore | boolean;
+/** Test if any element is true */
+export declare function any(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArrayCore | boolean;
+/** Cumulative sum */
+export declare function cumsum(a: NDArrayCore, axis?: number): NDArrayCore;
+/** Alias for cumsum */
+export declare const cumulative_sum: typeof cumsum;
+/** Cumulative product */
+export declare function cumprod(a: NDArrayCore, axis?: number): NDArrayCore;
+/** Alias for cumprod */
+export declare const cumulative_prod: typeof cumprod;
+/** Sum ignoring NaN */
+export declare function nansum(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArrayCore | number | Complex;
+/** Product ignoring NaN */
+export declare function nanprod(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArrayCore | number | Complex;
+/** Mean ignoring NaN */
+export declare function nanmean(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArrayCore | number | Complex;
+/** Variance ignoring NaN */
+export declare function nanvar(a: NDArrayCore, axis?: number, ddof?: number, keepdims?: boolean): NDArrayCore | number;
+/** Standard deviation ignoring NaN */
+export declare function nanstd(a: NDArrayCore, axis?: number, ddof?: number, keepdims?: boolean): NDArrayCore | number;
+/** Minimum ignoring NaN */
+export declare function nanmin(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArrayCore | number | Complex;
+/** Maximum ignoring NaN */
+export declare function nanmax(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArrayCore | number | Complex;
+/** Index of minimum ignoring NaN */
+export declare function nanargmin(a: NDArrayCore, axis?: number): NDArrayCore | number;
+/** Index of maximum ignoring NaN */
+export declare function nanargmax(a: NDArrayCore, axis?: number): NDArrayCore | number;
+/** Cumulative sum ignoring NaN */
+export declare function nancumsum(a: NDArrayCore, axis?: number): NDArrayCore;
+/** Cumulative product ignoring NaN */
+export declare function nancumprod(a: NDArrayCore, axis?: number): NDArrayCore;
+/** Median ignoring NaN */
+export declare function nanmedian(a: NDArrayCore, axis?: number, keepdims?: boolean): NDArrayCore | number;
+/** Quantile ignoring NaN */
+export declare function nanquantile(a: NDArrayCore, q: number, axis?: number, keepdims?: boolean): NDArrayCore | number;
+/** Percentile ignoring NaN */
+export declare function nanpercentile(a: NDArrayCore, q: number, axis?: number, keepdims?: boolean): NDArrayCore | number;
+//# sourceMappingURL=reduction.d.ts.map

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

@@ -0,0 +1,24 @@
+/**
+ * Rounding Functions - Tree-shakeable standalone functions
+ *
+ * This module provides rounding operations that can be
+ * imported independently for optimal tree-shaking.
+ */
+import { NDArrayCore } from './types';
+/** Round to given decimals */
+export declare function around(a: NDArrayCore, decimals?: number): NDArrayCore;
+/** Alias for around */
+export declare const round_: typeof around;
+/** Round (same as around) */
+export declare function round(a: NDArrayCore, decimals?: number): NDArrayCore;
+/** Ceiling */
+export declare function ceil(x: NDArrayCore): NDArrayCore;
+/** Round toward zero */
+export declare function fix(x: NDArrayCore): NDArrayCore;
+/** Floor */
+export declare function floor(x: NDArrayCore): NDArrayCore;
+/** Round to nearest integer */
+export declare function rint(x: NDArrayCore): NDArrayCore;
+/** Truncate toward zero */
+export declare function trunc(x: NDArrayCore): NDArrayCore;
+//# sourceMappingURL=rounding.d.ts.map

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

@@ -0,0 +1,48 @@
+/**
+ * Set Operations - Tree-shakeable standalone functions
+ *
+ * This module provides set operations that can be
+ * imported independently for optimal tree-shaking.
+ */
+import { NDArrayCore } from './types';
+/** Find unique elements */
+export declare function unique(ar: NDArrayCore, returnIndex?: boolean, returnInverse?: boolean, returnCounts?: boolean): NDArrayCore | {
+    values: NDArrayCore;
+    indices?: NDArrayCore;
+    inverse?: NDArrayCore;
+    counts?: NDArrayCore;
+};
+/** Test if elements in ar1 are in ar2 (deprecated, use isin) */
+export declare function in1d(ar1: NDArrayCore, ar2: NDArrayCore): NDArrayCore;
+/** Find intersection of two arrays */
+export declare function intersect1d(ar1: NDArrayCore, ar2: NDArrayCore): NDArrayCore;
+/** Test if elements are in test elements */
+export declare function isin(element: NDArrayCore, testElements: NDArrayCore): NDArrayCore;
+/** Find set difference (elements in ar1 not in ar2) */
+export declare function setdiff1d(ar1: NDArrayCore, ar2: NDArrayCore): NDArrayCore;
+/** Find symmetric difference (elements in either but not both) */
+export declare function setxor1d(ar1: NDArrayCore, ar2: NDArrayCore): NDArrayCore;
+/** Find union of two arrays */
+export declare function union1d(ar1: NDArrayCore, ar2: NDArrayCore): NDArrayCore;
+/** Trim leading/trailing zeros */
+export declare function trim_zeros(filt: NDArrayCore, trim?: 'f' | 'b' | 'fb'): NDArrayCore;
+/** Return all unique values and metadata (Array API) */
+export declare function unique_all(x: NDArrayCore): {
+    values: NDArrayCore;
+    indices: NDArrayCore;
+    inverse_indices: NDArrayCore;
+    counts: NDArrayCore;
+};
+/** Return unique values and counts (Array API) */
+export declare function unique_counts(x: NDArrayCore): {
+    values: NDArrayCore;
+    counts: NDArrayCore;
+};
+/** Return unique values and inverse indices (Array API) */
+export declare function unique_inverse(x: NDArrayCore): {
+    values: NDArrayCore;
+    inverse_indices: NDArrayCore;
+};
+/** Return unique values (Array API) */
+export declare function unique_values(x: NDArrayCore): NDArrayCore;
+//# sourceMappingURL=sets.d.ts.map

package/dist/types/core/shape-extra.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Additional shape manipulation functions
+ *
+ * Tree-shakeable standalone functions for array manipulation.
+ */
+import { NDArrayCore } from '../common/ndarray-core';
+/**
+ * Append values to the end of an array
+ */
+export declare function append(arr: NDArrayCore, values: NDArrayCore | number | number[], axis?: number): NDArrayCore;
+/**
+ * Delete elements from an array
+ */
+export declare function delete_(arr: NDArrayCore, obj: number | number[], axis?: number): NDArrayCore;
+export { delete_ as delete };
+/**
+ * Insert values along an axis
+ */
+export declare function insert(arr: NDArrayCore, obj: number | number[], values: NDArrayCore | number | number[], axis?: number): NDArrayCore;
+/**
+ * Pad an array
+ */
+export declare function pad(arr: NDArrayCore, pad_width: number | [number, number] | [number, number][], mode?: 'constant' | 'edge' | 'linear_ramp' | 'maximum' | 'mean' | 'median' | 'minimum' | 'reflect' | 'symmetric' | 'wrap' | 'empty', constant_values?: number): NDArrayCore;
+//# sourceMappingURL=shape-extra.d.ts.map

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

@@ -0,0 +1,77 @@
+/**
+ * Shape Manipulation Functions - Tree-shakeable standalone functions
+ *
+ * This module provides array shape manipulation functions that can be
+ * imported independently for optimal tree-shaking.
+ */
+import { NDArrayCore } from './types';
+/** Reshape array without changing data */
+export declare function reshape(a: NDArrayCore, newShape: number[]): NDArrayCore;
+/** Flatten array to 1D */
+export declare function flatten(a: NDArrayCore): NDArrayCore;
+/** Return contiguous flattened array */
+export declare function ravel(a: NDArrayCore): NDArrayCore;
+/** Remove single-dimensional entries from shape - returns a view */
+export declare function squeeze(a: NDArrayCore, axis?: number): NDArrayCore;
+/** Expand array dimensions - returns a view */
+export declare function expand_dims(a: NDArrayCore, axis: number): NDArrayCore;
+/** Interchange two axes - returns a view */
+export declare function swapaxes(a: NDArrayCore, axis1: number, axis2: number): NDArrayCore;
+/** Move axis to new position - returns a view */
+export declare function moveaxis(a: NDArrayCore, source: number | number[], destination: number | number[]): NDArrayCore;
+/** Roll axis to given position - returns a view */
+export declare function rollaxis(a: NDArrayCore, axis: number, start?: number): NDArrayCore;
+/** Join arrays along an existing axis */
+export declare function concatenate(arrays: NDArrayCore[], axis?: number): NDArrayCore;
+/** Join arrays along a new axis */
+export declare function stack(arrays: NDArrayCore[], axis?: number): NDArrayCore;
+/** Stack arrays vertically (row-wise) */
+export declare function vstack(arrays: NDArrayCore[]): NDArrayCore;
+/** Stack arrays horizontally (column-wise) */
+export declare function hstack(arrays: NDArrayCore[]): NDArrayCore;
+/** Stack arrays along third axis (depth-wise) */
+export declare function dstack(arrays: NDArrayCore[]): NDArrayCore;
+/** Concatenate (alias) */
+export declare function concat(arrays: NDArrayCore[], axis?: number): NDArrayCore;
+/** Stack 1D arrays as columns */
+export declare function column_stack(arrays: NDArrayCore[]): NDArrayCore;
+/** vstack alias */
+export declare const row_stack: typeof vstack;
+/** Assemble arrays from nested sequences of blocks */
+export declare function block(arrays: NDArrayCore[]): NDArrayCore;
+/** Split array into multiple sub-arrays - returns views */
+export declare function split(a: NDArrayCore, indicesOrSections: number | number[], axis?: number): NDArrayCore[];
+/** Split array into multiple sub-arrays (may have unequal sizes) - returns views */
+export declare function array_split(a: NDArrayCore, indicesOrSections: number | number[], axis?: number): NDArrayCore[];
+/** Split array vertically - returns views */
+export declare function vsplit(a: NDArrayCore, indicesOrSections: number | number[]): NDArrayCore[];
+/** Split array horizontally - returns views */
+export declare function hsplit(a: NDArrayCore, indicesOrSections: number | number[]): NDArrayCore[];
+/** Split array along third axis */
+/** Split array along depth axis - returns views */
+export declare function dsplit(ary: NDArrayCore, indices_or_sections: number | number[]): NDArrayCore[];
+/** Unstack array into list of arrays */
+export declare function unstack(a: NDArrayCore, axis?: number): NDArrayCore[];
+/** Tile array by given repetitions */
+export declare function tile(a: NDArrayCore, reps: number | number[]): NDArrayCore;
+/** Repeat elements of array */
+export declare function repeat(a: NDArrayCore, repeats: number | number[], axis?: number): NDArrayCore;
+/** Reverse order of elements along axis */
+export declare function flip(m: NDArrayCore, axis?: number | number[]): NDArrayCore;
+/** Flip array left/right */
+export declare function fliplr(m: NDArrayCore): NDArrayCore;
+/** Flip array up/down */
+export declare function flipud(m: NDArrayCore): NDArrayCore;
+/** Rotate array by 90 degrees */
+export declare function rot90(m: NDArrayCore, k?: number, axes?: [number, number]): NDArrayCore;
+/** Roll array elements along axis */
+export declare function roll(a: NDArrayCore, shift: number | number[], axis?: number | number[]): NDArrayCore;
+/** Resize array to new shape */
+export declare function resize(a: NDArrayCore, new_shape: number[]): NDArrayCore;
+/** Ensure array has at least 1 dimension */
+export declare function atleast_1d(...arrays: NDArrayCore[]): NDArrayCore | NDArrayCore[];
+/** Ensure array has at least 2 dimensions */
+export declare function atleast_2d(...arrays: NDArrayCore[]): NDArrayCore | NDArrayCore[];
+/** Ensure array has at least 3 dimensions */
+export declare function atleast_3d(...arrays: NDArrayCore[]): NDArrayCore | NDArrayCore[];
+//# sourceMappingURL=shape.d.ts.map

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

@@ -0,0 +1,34 @@
+/**
+ * Sorting and Searching Functions - Tree-shakeable standalone functions
+ *
+ * This module provides sorting, searching, and counting functions that can be
+ * imported independently for optimal tree-shaking.
+ */
+import { NDArrayCore } from './types';
+/** Sort array along axis */
+export declare function sort(a: NDArrayCore, axis?: number): NDArrayCore;
+/** Indices that would sort array */
+export declare function argsort(a: NDArrayCore, axis?: number): NDArrayCore;
+/** Indirect stable sort on multiple keys */
+export declare function lexsort(keys: NDArrayCore[]): NDArrayCore;
+/** Partially sort array */
+export declare function partition(a: NDArrayCore, kth: number, axis?: number): NDArrayCore;
+/** Indices that would partially sort array */
+export declare function argpartition(a: NDArrayCore, kth: number, axis?: number): NDArrayCore;
+/** Sort complex array */
+export declare function sort_complex(a: NDArrayCore): NDArrayCore;
+/** Indices of non-zero elements */
+export declare function nonzero(a: NDArrayCore): NDArrayCore[];
+/** Indices where condition is True */
+export declare function argwhere(a: NDArrayCore): NDArrayCore;
+/** Indices of non-zero elements in flattened array */
+export declare function flatnonzero(a: NDArrayCore): NDArrayCore;
+/** Return elements from x or y based on condition */
+export declare function where(condition: NDArrayCore, x?: NDArrayCore, y?: NDArrayCore): NDArrayCore | NDArrayCore[];
+/** Find indices for inserting elements to maintain order */
+export declare function searchsorted(a: NDArrayCore, v: NDArrayCore, side?: 'left' | 'right'): NDArrayCore;
+/** Extract elements where condition is True */
+export declare function extract(condition: NDArrayCore, a: NDArrayCore): NDArrayCore;
+/** Count non-zero elements */
+export declare function count_nonzero(a: NDArrayCore, axis?: number): NDArrayCore | number;
+//# sourceMappingURL=sorting.d.ts.map

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

@@ -0,0 +1,32 @@
+/**
+ * Statistics Functions - Tree-shakeable standalone functions
+ *
+ * This module provides statistical operations that can be
+ * imported independently for optimal tree-shaking.
+ */
+import { NDArrayCore } from './types';
+type BinStrategyString = 'auto' | 'fd' | 'doane' | 'scott' | 'stone' | 'rice' | 'sturges' | 'sqrt';
+/** Count occurrences of values */
+export declare function bincount(x: NDArrayCore, weights?: NDArrayCore, minlength?: number): NDArrayCore;
+/** Digitize values into bins */
+export declare function digitize(x: NDArrayCore, bins: NDArrayCore, right?: boolean): NDArrayCore;
+/** Compute histogram */
+export declare function histogram(a: NDArrayCore, bins?: number | NDArrayCore | BinStrategyString, range?: [number, number], density?: boolean, weights?: NDArrayCore): [NDArrayCore, NDArrayCore];
+/** Compute 2D histogram */
+export declare function histogram2d(x: NDArrayCore, y: NDArrayCore, bins?: number | [number, number] | [NDArrayCore, NDArrayCore], range?: [[number, number], [number, number]], density?: boolean, weights?: NDArrayCore): [NDArrayCore, NDArrayCore, NDArrayCore];
+/** Compute N-dimensional histogram */
+export declare function histogramdd(sample: NDArrayCore, bins?: number | number[], range?: [number, number][], density?: boolean, weights?: NDArrayCore): [NDArrayCore, NDArrayCore[]];
+/** Cross-correlation */
+export declare function correlate(a: NDArrayCore, v: NDArrayCore, mode?: 'valid' | 'same' | 'full'): NDArrayCore;
+/** Convolution */
+export declare function convolve(a: NDArrayCore, v: NDArrayCore, mode?: 'valid' | 'same' | 'full'): NDArrayCore;
+/** Covariance matrix */
+export declare function cov(m: NDArrayCore, y?: NDArrayCore, rowvar?: boolean, bias?: boolean, ddof?: number): NDArrayCore;
+/** Correlation coefficients */
+export declare function corrcoef(x: NDArrayCore, y?: NDArrayCore, rowvar?: boolean): NDArrayCore;
+/** Compute histogram bin edges */
+export declare function histogram_bin_edges(a: NDArrayCore, bins?: number | BinStrategyString, range?: [number, number], weights?: NDArrayCore): NDArrayCore;
+/** Integrate using trapezoidal rule */
+export declare function trapezoid(y: NDArrayCore, x?: NDArrayCore, dx?: number, axis?: number): NDArrayCore | number;
+export {};
+//# sourceMappingURL=statistics.d.ts.map

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

@@ -0,0 +1,58 @@
+/**
+ * Trigonometric Functions - Tree-shakeable standalone functions
+ *
+ * This module provides trigonometric and hyperbolic functions that can be
+ * imported independently for optimal tree-shaking.
+ */
+import { NDArrayCore } from './types';
+/** Sine of array elements */
+export declare function sin(x: NDArrayCore): NDArrayCore;
+/** Cosine of array elements */
+export declare function cos(x: NDArrayCore): NDArrayCore;
+/** Tangent of array elements */
+export declare function tan(x: NDArrayCore): NDArrayCore;
+/** Inverse sine */
+export declare function arcsin(x: NDArrayCore): NDArrayCore;
+/** Alias for arcsin */
+export declare const asin: typeof arcsin;
+/** Inverse cosine */
+export declare function arccos(x: NDArrayCore): NDArrayCore;
+/** Alias for arccos */
+export declare const acos: typeof arccos;
+/** Inverse tangent */
+export declare function arctan(x: NDArrayCore): NDArrayCore;
+/** Alias for arctan */
+export declare const atan: typeof arctan;
+/** Two-argument inverse tangent */
+export declare function arctan2(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Alias for arctan2 */
+export declare const atan2: typeof arctan2;
+/** Hypotenuse (sqrt(x1^2 + x2^2)) */
+export declare function hypot(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Convert radians to degrees */
+export declare function degrees(x: NDArrayCore): NDArrayCore;
+/** Convert degrees to radians */
+export declare function radians(x: NDArrayCore): NDArrayCore;
+/** Convert degrees to radians (alias) */
+export declare function deg2rad(x: NDArrayCore): NDArrayCore;
+/** Convert radians to degrees (alias) */
+export declare function rad2deg(x: NDArrayCore): NDArrayCore;
+/** Hyperbolic sine */
+export declare function sinh(x: NDArrayCore): NDArrayCore;
+/** Hyperbolic cosine */
+export declare function cosh(x: NDArrayCore): NDArrayCore;
+/** Hyperbolic tangent */
+export declare function tanh(x: NDArrayCore): NDArrayCore;
+/** Inverse hyperbolic sine */
+export declare function arcsinh(x: NDArrayCore): NDArrayCore;
+/** Alias for arcsinh */
+export declare const asinh: typeof arcsinh;
+/** Inverse hyperbolic cosine */
+export declare function arccosh(x: NDArrayCore): NDArrayCore;
+/** Alias for arccosh */
+export declare const acosh: typeof arccosh;
+/** Inverse hyperbolic tangent */
+export declare function arctanh(x: NDArrayCore): NDArrayCore;
+/** Alias for arctanh */
+export declare const atanh: typeof arctanh;
+//# sourceMappingURL=trig.d.ts.map

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

@@ -0,0 +1,50 @@
+/**
+ * Type checking and dtype utility functions
+ *
+ * Tree-shakeable standalone functions for dtype operations.
+ */
+import { NDArrayCore, type DType } from '../common/ndarray-core';
+/**
+ * Check if a cast between dtypes is possible according to the casting rule
+ */
+export declare function can_cast(from_: DType | NDArrayCore, to: DType, casting?: 'no' | 'equiv' | 'safe' | 'same_kind' | 'unsafe'): boolean;
+/**
+ * Return a scalar type common to input arrays
+ *
+ * This returns a floating-point type that can represent all input types.
+ * Integers are promoted to floats that can hold their full range.
+ */
+export declare function common_type(...arrays: NDArrayCore[]): DType;
+/**
+ * Return the type that results from applying promotion rules
+ *
+ * NumPy-compatible type promotion:
+ * - Integers promote to larger integers that can hold both ranges
+ * - int32 + uint32 -> int64 (needs signed type that fits both)
+ * - Integer + float -> float64 if integer is 32+ bits
+ * - float32 + complex64 -> complex64
+ * - float64 + complex64 -> complex128
+ */
+export declare function result_type(...arrays_and_dtypes: (NDArrayCore | DType)[]): DType;
+/**
+ * Return the minimum scalar type needed to represent a value
+ */
+export declare function min_scalar_type(val: number | bigint | boolean): DType;
+/**
+ * Check if dtype1 is a subtype of dtype2
+ */
+export declare function issubdtype(dtype1: DType | NDArrayCore, dtype2: DType | string): boolean;
+/**
+ * Return a description for the given dtype
+ *
+ * Returns the dtype name directly (NumPy compatible).
+ */
+export declare function typename(dtype: DType): string;
+/**
+ * Return the character code of the minimum-size type needed
+ *
+ * Returns the minimum type from typeset that can safely represent all input types.
+ * Uses safe casting rules to ensure no precision loss.
+ */
+export declare function mintypecode(typechars: string, typeset?: string, default_?: string): string;
+//# sourceMappingURL=typechecking.d.ts.map

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

@@ -0,0 +1,43 @@
+/**
+ * Shared types for standalone function modules
+ *
+ * This module provides type definitions and helper functions used by
+ * standalone function wrappers for tree-shaking support.
+ */
+import { NDArrayCore } from '../common/ndarray-core';
+import { ArrayStorage } from '../common/storage';
+import { Complex } from '../common/complex';
+export type { DType, TypedArray } from '../common/dtype';
+export { NDArrayCore, ArrayStorage, Complex };
+/**
+ * Input type for functions that accept arrays
+ * Can be an NDArrayCore instance or nested arrays
+ */
+export type ArrayLike = NDArrayCore | number[] | number[][] | number[][][] | number | bigint;
+/**
+ * Convert input to ArrayStorage
+ * Handles both NDArrayCore and NDArray (which has _storage property)
+ */
+export declare function toStorage(a: NDArrayCore | ArrayStorage): ArrayStorage;
+/**
+ * Wrap ArrayStorage result in NDArrayCore
+ */
+export declare function fromStorage(storage: ArrayStorage, base?: NDArrayCore): NDArrayCore;
+/**
+ * Wrap ArrayStorage result in NDArrayCore as a view of the input array
+ * Sets the base to track the view relationship
+ */
+export declare function fromStorageView(storage: ArrayStorage, original: NDArrayCore): NDArrayCore;
+/**
+ * Wrap multiple ArrayStorage results
+ */
+export declare function fromStorageArray(storages: ArrayStorage[]): NDArrayCore[];
+/**
+ * Wrap multiple ArrayStorage results as views of the original array
+ */
+export declare function fromStorageViewArray(storages: ArrayStorage[], original: NDArrayCore): NDArrayCore[];
+/**
+ * Wrap a tuple of ArrayStorage results
+ */
+export declare function fromStorageTuple(tuple: [ArrayStorage, ArrayStorage]): [NDArrayCore, NDArrayCore];
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,30 @@
+/**
+ * Utility functions
+ *
+ * Tree-shakeable standalone functions for array introspection.
+ */
+import { NDArrayCore, type DType } from '../common/ndarray-core';
+import { Complex } from '../common/complex';
+/**
+ * Return the number of dimensions of an array.
+ * Works with NDArrayCore, scalars, and nested arrays.
+ */
+export declare function ndim(a: NDArrayCore | number | bigint | boolean | unknown[] | unknown): number;
+/**
+ * Return the shape of an array.
+ * Works with NDArrayCore, scalars, and nested arrays.
+ */
+export declare function shape(a: NDArrayCore | number | bigint | boolean | unknown[] | unknown): readonly number[] | number[];
+/**
+ * Return the number of elements in an array.
+ * Works with NDArrayCore, scalars, and nested arrays.
+ */
+export declare function size(a: NDArrayCore | number | bigint | boolean | unknown[] | unknown): number;
+export declare function item(a: NDArrayCore, ...args: number[]): number | bigint | boolean | Complex;
+export declare function tolist(a: NDArrayCore): unknown;
+export declare function tobytes(a: NDArrayCore, order?: 'C' | 'F'): Uint8Array;
+export declare function byteswap(a: NDArrayCore, inplace?: boolean): NDArrayCore;
+export declare function view(a: NDArrayCore, dtype?: DType): NDArrayCore;
+export declare function tofile(_a: NDArrayCore, _file: string, _sep?: string, _format?: string): void;
+export declare function fill(a: NDArrayCore, value: number | bigint | boolean | Complex): void;
+//# sourceMappingURL=utility.d.ts.map

package/dist/types/core.d.ts

@@ -0,0 +1,30 @@
+/**
+ * numpy-ts/core - Tree-shakeable entry point
+ *
+ * This module provides standalone functions that return NDArrayCore.
+ * Use this entry point when bundle size is critical and you don't need method chaining.
+ *
+ * All functions in this module are designed for optimal tree-shaking.
+ * Import only what you need to get minimal bundle sizes.
+ *
+ * @example
+ * ```typescript
+ * import { array, add, reshape } from 'numpy-ts/core';
+ *
+ * const a = array([1, 2, 3, 4]);
+ * const b = add(a, 10);              // Standalone function
+ * const c = reshape(b, [2, 2]);      // Standalone function
+ * console.log(c.shape);              // [2, 2]
+ * ```
+ *
+ * For method chaining, use the main entry point instead:
+ * ```typescript
+ * import { array } from 'numpy-ts';
+ *
+ * const c = array([1, 2, 3, 4]).add(10).reshape([2, 2]);
+ * ```
+ *
+ * @module numpy-ts/core
+ */
+export * from './core/index';
+//# sourceMappingURL=core.d.ts.map