numpy-ts 0.12.0 → 0.13.0

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

@@ -0,0 +1,141 @@
+/**
+ * Linear Algebra Functions - Tree-shakeable standalone functions
+ *
+ * This module provides linear algebra functions that can be
+ * imported independently for optimal tree-shaking.
+ */
+import { NDArrayCore, Complex } from './types';
+/** Dot product of two arrays */
+export declare function dot(a: NDArrayCore, b: NDArrayCore): NDArrayCore | number | bigint | Complex;
+/** Matrix trace (sum of diagonal elements) */
+export declare function trace(a: NDArrayCore): number | bigint | Complex;
+/** Return diagonal or construct diagonal array */
+export declare function diagonal(a: NDArrayCore, offset?: number, axis1?: number, axis2?: number): NDArrayCore;
+/** Kronecker product */
+export declare function kron(a: NDArrayCore, b: NDArrayCore): NDArrayCore;
+/** Transpose array - returns a view */
+export declare function transpose(a: NDArrayCore, axes?: number[]): NDArrayCore;
+/** Inner product of two arrays */
+export declare function inner(a: NDArrayCore, b: NDArrayCore): NDArrayCore | number | bigint | Complex;
+/** Outer product of two arrays */
+export declare function outer(a: NDArrayCore, b: NDArrayCore): NDArrayCore;
+/** Tensor dot product */
+export declare function tensordot(a: NDArrayCore, b: NDArrayCore, axes?: number | [number[], number[]]): NDArrayCore | number | bigint | Complex;
+/** Evaluates Einstein summation convention */
+export declare function einsum(subscripts: string, ...operands: NDArrayCore[]): NDArrayCore | number | bigint | Complex;
+/** Compute the optimal contraction path for einsum */
+export declare function einsum_path(subscripts: string, ...operands: NDArrayCore[]): [([number, number] | number[])[], string];
+/** Vector dot product */
+export declare function vdot(a: NDArrayCore, b: NDArrayCore): number | bigint | Complex;
+/** Vector dot product along specified axis */
+export declare function vecdot(x1: NDArrayCore, x2: NDArrayCore, axis?: number): NDArrayCore | number | bigint | Complex;
+/** Matrix transpose (swap last two axes) */
+/** Matrix transpose - returns a view */
+export declare function matrix_transpose(a: NDArrayCore): NDArrayCore;
+/** Permute array dimensions - returns a view */
+export declare function permute_dims(a: NDArrayCore, axes?: number[]): NDArrayCore;
+/** Matrix-vector product */
+export declare function matvec(x1: NDArrayCore, x2: NDArrayCore): NDArrayCore;
+/** Vector-matrix product */
+export declare function vecmat(x1: NDArrayCore, x2: NDArrayCore): NDArrayCore;
+/** Cross product */
+export declare function cross(a: NDArrayCore, b: NDArrayCore, axisa?: number, axisb?: number, axisc?: number, axis?: number): NDArrayCore | number | Complex;
+/** Matrix multiplication */
+export declare function matmul(a: NDArrayCore, b: NDArrayCore): NDArrayCore;
+export declare const linalg: {
+    /** Matrix multiplication */
+    matmul: (a: NDArrayCore, b: NDArrayCore) => NDArrayCore;
+    /** Dot product */
+    dot: (a: NDArrayCore, b: NDArrayCore) => NDArrayCore | number | bigint | Complex;
+    /** Matrix determinant */
+    det: (a: NDArrayCore) => number;
+    /** Matrix inverse */
+    inv: (a: NDArrayCore) => NDArrayCore;
+    /** Solve linear system Ax = b */
+    solve: (a: NDArrayCore, b: NDArrayCore) => NDArrayCore;
+    /** Least-squares solution */
+    lstsq: (a: NDArrayCore, b: NDArrayCore, rcond?: number | null) => {
+        x: NDArrayCore;
+        residuals: NDArrayCore;
+        rank: number;
+        s: NDArrayCore;
+    };
+    /** Matrix or vector norm */
+    norm: (x: NDArrayCore, ord?: number | "fro" | "nuc" | null, axis?: number | [number, number] | null, keepdims?: boolean) => NDArrayCore | number;
+    /** Condition number */
+    cond: (a: NDArrayCore, p?: number | "fro" | "nuc") => number;
+    /** Matrix rank */
+    matrix_rank: (a: NDArrayCore, tol?: number) => number;
+    /** Raise matrix to a power */
+    matrix_power: (a: NDArrayCore, n: number) => NDArrayCore;
+    /** Pseudo-inverse */
+    pinv: (a: NDArrayCore, rcond?: number) => NDArrayCore;
+    /** QR decomposition */
+    qr: (a: NDArrayCore, mode?: "reduced" | "complete" | "r" | "raw") => {
+        q: NDArrayCore;
+        r: NDArrayCore;
+    } | NDArrayCore | {
+        h: NDArrayCore;
+        tau: NDArrayCore;
+    };
+    /** Cholesky decomposition */
+    cholesky: (a: NDArrayCore, upper?: boolean) => NDArrayCore;
+    /** Singular value decomposition */
+    svd: (a: NDArrayCore, full_matrices?: boolean, compute_uv?: boolean) => {
+        u: NDArrayCore;
+        s: NDArrayCore;
+        vt: NDArrayCore;
+    } | NDArrayCore;
+    /** Eigenvalues and eigenvectors */
+    eig: (a: NDArrayCore) => {
+        w: NDArrayCore;
+        v: NDArrayCore;
+    };
+    /** Eigenvalues and eigenvectors of Hermitian matrix */
+    eigh: (a: NDArrayCore, UPLO?: "L" | "U") => {
+        w: NDArrayCore;
+        v: NDArrayCore;
+    };
+    /** Eigenvalues */
+    eigvals: (a: NDArrayCore) => NDArrayCore;
+    /** Eigenvalues of Hermitian matrix */
+    eigvalsh: (a: NDArrayCore, UPLO?: "L" | "U") => NDArrayCore;
+    /** Sign and log of determinant */
+    slogdet: (a: NDArrayCore) => {
+        sign: number;
+        logabsdet: number;
+    };
+    /** Singular values */
+    svdvals: (a: NDArrayCore) => NDArrayCore;
+    /** Chained dot product */
+    multi_dot: (arrays: NDArrayCore[]) => NDArrayCore;
+    /** Inverse of tensorization */
+    tensorinv: (a: NDArrayCore, ind?: number) => NDArrayCore;
+    /** Tensor equation solution */
+    tensorsolve: (a: NDArrayCore, b: NDArrayCore, axes?: number[]) => NDArrayCore;
+    /** Vector norm */
+    vector_norm: (x: NDArrayCore, ord?: number | "fro" | "nuc", axis?: number | null, keepdims?: boolean) => NDArrayCore | number;
+    /** Matrix norm */
+    matrix_norm: (x: NDArrayCore, ord?: number | "fro" | "nuc", keepdims?: boolean) => NDArrayCore | number;
+    /** Cross product */
+    cross: (a: NDArrayCore, b: NDArrayCore, axisa?: number, axisb?: number, axisc?: number, axis?: number) => NDArrayCore | number | Complex;
+    /** Matrix transpose (transposes last two axes) - returns a view */
+    matrix_transpose: (a: NDArrayCore) => NDArrayCore;
+    /** Permute array dimensions - returns a view */
+    permute_dims: (a: NDArrayCore, axes?: number[]) => NDArrayCore;
+    /** Matrix trace (sum of diagonal elements) */
+    trace: (a: NDArrayCore) => number | bigint | Complex;
+    /** Extract diagonal */
+    diagonal: (a: NDArrayCore, offset?: number, axis1?: number, axis2?: number) => NDArrayCore;
+    /** Outer product */
+    outer: (a: NDArrayCore, b: NDArrayCore) => NDArrayCore;
+    /** Inner product */
+    inner: (a: NDArrayCore, b: NDArrayCore) => NDArrayCore | number | bigint | Complex;
+    /** Tensor dot product */
+    tensordot: (a: NDArrayCore, b: NDArrayCore, axes?: number | [number[], number[]]) => NDArrayCore | number | bigint | Complex;
+    /** Vector dot product */
+    vecdot: (a: NDArrayCore, b: NDArrayCore, axis?: number) => NDArrayCore | number | bigint | Complex;
+    /** Transpose array - returns a view */
+    transpose: (a: NDArrayCore, axes?: number[]) => NDArrayCore;
+};
+//# sourceMappingURL=linalg.d.ts.map

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

@@ -0,0 +1,72 @@
+/**
+ * Logic Functions - Tree-shakeable standalone functions
+ *
+ * This module provides logical and type-checking functions that can be
+ * imported independently for optimal tree-shaking.
+ */
+import { NDArrayCore, type DType } from './types';
+/** Element-wise logical AND */
+export declare function logical_and(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Element-wise logical OR */
+export declare function logical_or(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Element-wise logical NOT */
+export declare function logical_not(x: NDArrayCore): NDArrayCore;
+/** Element-wise logical XOR */
+export declare function logical_xor(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Test for finite values */
+export declare function isfinite(x: NDArrayCore): NDArrayCore;
+/** Test for infinity */
+export declare function isinf(x: NDArrayCore): NDArrayCore;
+/** Test for NaN */
+export declare function isnan(x: NDArrayCore): NDArrayCore;
+/** Test for NaT (not a time) - returns all False for numeric arrays */
+export declare function isnat(x: NDArrayCore): NDArrayCore;
+/** Test for negative infinity */
+export declare function isneginf(x: NDArrayCore): NDArrayCore;
+/** Test for positive infinity */
+export declare function isposinf(x: NDArrayCore): NDArrayCore;
+/** Element-wise test for complex values */
+export declare function iscomplex(x: NDArrayCore): NDArrayCore;
+/** Check if array has complex dtype */
+export declare function iscomplexobj(x: NDArrayCore): boolean;
+/** Element-wise test for real values */
+export declare function isreal(x: NDArrayCore): NDArrayCore;
+/** Check if array has real dtype */
+export declare function isrealobj(x: NDArrayCore): boolean;
+/** Return real array if imaginary part is negligible */
+export declare function real_if_close(x: NDArrayCore, tol?: number): NDArrayCore;
+/** Check if array is Fortran contiguous */
+export declare function isfortran(x: NDArrayCore): boolean;
+/** Check if value is a scalar */
+export declare function isscalar(val: unknown): boolean;
+/** Check if object is iterable */
+export declare function iterable(obj: unknown): boolean;
+/** Check dtype against a kind string */
+export declare function isdtype(dtype: DType, kind: string): boolean;
+/** Promote dtypes to a common type */
+export declare function promote_types(dtype1: DType, dtype2: DType): DType;
+/** Return sign of x1 with magnitude of x2 */
+export declare function copysign(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Test for negative sign bit */
+export declare function signbit(x: NDArrayCore): NDArrayCore;
+/** Next floating-point value toward x2 */
+export declare function nextafter(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Spacing between x and nearest adjacent number */
+export declare function spacing(x: NDArrayCore): NDArrayCore;
+/** Element-wise greater than comparison */
+export declare function greater(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Element-wise greater than or equal comparison */
+export declare function greater_equal(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Element-wise less than comparison */
+export declare function less(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Element-wise less than or equal comparison */
+export declare function less_equal(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Element-wise equality comparison */
+export declare function equal(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Element-wise inequality comparison */
+export declare function not_equal(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Element-wise close comparison with tolerance */
+export declare function isclose(a: NDArrayCore, b: NDArrayCore | number, rtol?: number, atol?: number): NDArrayCore;
+/** Check if all elements are close */
+export declare function allclose(a: NDArrayCore, b: NDArrayCore | number, rtol?: number, atol?: number): boolean;
+//# sourceMappingURL=logic.d.ts.map

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