numpy-ts 0.12.0 → 0.13.1

package/dist/types/{ops → common/ops}/reduction.d.ts

@@ -4,8 +4,8 @@
  * Pure functions for reducing arrays along axes.
  * @module ops/reduction
  */
-import { ArrayStorage } from '../core/storage';
-import { Complex } from '../core/complex';
+import { ArrayStorage } from '../storage';
+import { Complex } from '../complex';
 /**
  * Sum array elements over a given axis
  */

package/dist/types/{ops → common/ops}/rounding.d.ts

@@ -7,7 +7,7 @@
  * Note: Rounding operations are not defined for complex numbers.
  * All functions throw TypeError for complex dtypes.
  */
-import { ArrayStorage } from '../core/storage';
+import { ArrayStorage } from '../storage';
 /**
  * Round an array to the given number of decimals
  */

package/dist/types/{ops → common/ops}/sets.d.ts

@@ -1,7 +1,7 @@
 /**
  * Set operations
  */
-import { ArrayStorage } from '../core/storage';
+import { ArrayStorage } from '../storage';
 /**
  * Find the unique elements of an array
  */

package/dist/types/{ops → common/ops}/shape.d.ts

@@ -4,7 +4,7 @@
  * Pure functions for reshaping, transposing, and manipulating array dimensions.
  * @module ops/shape
  */
-import { ArrayStorage } from '../core/storage';
+import { ArrayStorage } from '../storage';
 /**
  * Reshape array to a new shape
  * Returns a view if array is C-contiguous, otherwise copies data

package/dist/types/{ops → common/ops}/sorting.d.ts

@@ -4,7 +4,7 @@
  * Functions for sorting arrays, finding sorted indices, and searching.
  * @module ops/sorting
  */
-import { ArrayStorage } from '../core/storage';
+import { ArrayStorage } from '../storage';
 /**
  * Return a sorted copy of an array
  * @param storage - Input array storage

package/dist/types/{ops → common/ops}/statistics.d.ts

@@ -4,7 +4,7 @@
  * Pure functions for statistical analysis.
  * @module ops/statistics
  */
-import { ArrayStorage } from '../core/storage';
+import { ArrayStorage } from '../storage';
 /**
  * Count number of occurrences of each value in array of non-negative ints.
  *

package/dist/types/{ops → common/ops}/trig.d.ts

@@ -7,7 +7,7 @@
  * These functions are used by NDArray methods but are separated
  * to keep the codebase modular and testable.
  */
-import { ArrayStorage } from '../core/storage';
+import { ArrayStorage } from '../storage';
 /**
  * Sine of each element (element-wise)
  * NumPy behavior: Always promotes to float64 for integer types

package/dist/types/{core → common}/storage.d.ts

@@ -17,6 +17,7 @@ export declare class ArrayStorage {
     private _strides;
     private _offset;
     private _dtype;
+    private _isCContiguous;
     constructor(data: TypedArray, shape: readonly number[], strides: readonly number[], offset: number, dtype: DType);
     /**
      * Shape of the array

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

@@ -0,0 +1,54 @@
+/**
+ * Advanced indexing and data manipulation functions
+ *
+ * Tree-shakeable standalone functions that wrap the underlying ops.
+ */
+import { NDArrayCore } from '../common/ndarray-core';
+import * as advancedOps from '../common/ops/advanced';
+/** Broadcast array to a new shape - returns a view */
+export declare function broadcast_to(a: NDArrayCore, shape: number[]): NDArrayCore;
+export declare function broadcast_arrays(...arrays: NDArrayCore[]): NDArrayCore[];
+export declare function broadcast_shapes(...shapes: number[][]): number[];
+export declare function take(a: NDArrayCore, indices: number[], axis?: number): NDArrayCore;
+export declare function put(a: NDArrayCore, indices: number[], values: NDArrayCore | number[]): void;
+export declare function take_along_axis(arr: NDArrayCore, indices: NDArrayCore, axis: number): NDArrayCore;
+export declare function put_along_axis(arr: NDArrayCore, indices: NDArrayCore, values: NDArrayCore, axis: number): void;
+export declare function choose(a: NDArrayCore, choices: NDArrayCore[]): NDArrayCore;
+export declare function compress(condition: NDArrayCore, a: NDArrayCore, axis?: number): NDArrayCore;
+/**
+ * Integer array indexing (fancy indexing)
+ *
+ * Select elements using an array of indices.
+ */
+export declare function iindex(a: NDArrayCore, indices: NDArrayCore | number[] | number[][], axis?: number): NDArrayCore;
+/**
+ * Boolean array indexing (fancy indexing with mask)
+ *
+ * Select elements where a boolean mask is true.
+ */
+export declare function bindex(a: NDArrayCore, mask: NDArrayCore, axis?: number): NDArrayCore;
+export declare function select(condlist: NDArrayCore[], choicelist: NDArrayCore[], defaultVal?: number): NDArrayCore;
+export declare function place(a: NDArrayCore, mask: NDArrayCore, vals: NDArrayCore): void;
+export declare function putmask(a: NDArrayCore, mask: NDArrayCore, values: NDArrayCore): void;
+export declare function copyto(dst: NDArrayCore, src: NDArrayCore | number | bigint): void;
+export declare function indices(dimensions: number[], dtype?: 'int32' | 'int64' | 'float64'): NDArrayCore;
+export declare function ix_(...args: NDArrayCore[]): NDArrayCore[];
+export declare function ravel_multi_index(multi_index: NDArrayCore[], dims: number[], mode?: 'raise' | 'wrap' | 'clip'): NDArrayCore;
+export declare function unravel_index(indices: NDArrayCore | number, shape: number[]): NDArrayCore[];
+export declare function diag_indices(n: number, ndim?: number): NDArrayCore[];
+export declare function diag_indices_from(a: NDArrayCore): NDArrayCore[];
+export declare function fill_diagonal(a: NDArrayCore, val: number, wrap?: boolean): void;
+export declare function tril_indices(n: number, k?: number, m?: number): NDArrayCore[];
+export declare function tril_indices_from(a: NDArrayCore, k?: number): NDArrayCore[];
+export declare function triu_indices(n: number, k?: number, m?: number): NDArrayCore[];
+export declare function triu_indices_from(a: NDArrayCore, k?: number): NDArrayCore[];
+export declare function mask_indices(n: number, mask_func: (n: number, k: number) => NDArrayCore, k?: number): NDArrayCore[];
+export declare function array_equal(a: NDArrayCore, b: NDArrayCore, equal_nan?: boolean): boolean;
+export declare function array_equiv(a: NDArrayCore, b: NDArrayCore): boolean;
+export declare function apply_along_axis(func1d: (arr: NDArrayCore) => NDArrayCore | number, axis: number, arr: NDArrayCore): NDArrayCore;
+export declare function apply_over_axes(func: (arr: NDArrayCore, axis: number) => NDArrayCore, a: NDArrayCore, axes: number[]): NDArrayCore;
+export declare function may_share_memory(a: NDArrayCore, b: NDArrayCore): boolean;
+export declare function shares_memory(a: NDArrayCore, b: NDArrayCore): boolean;
+export declare const geterr: typeof advancedOps.geterr;
+export declare const seterr: typeof advancedOps.seterr;
+//# sourceMappingURL=advanced.d.ts.map

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

@@ -0,0 +1,110 @@
+/**
+ * Arithmetic Functions - Tree-shakeable standalone functions
+ *
+ * This module provides arithmetic and mathematical functions that can be
+ * imported independently for optimal tree-shaking.
+ *
+ * Import from here for minimal bundle size:
+ *   import { sqrt, exp, abs } from 'numpy-ts/functions/arithmetic';
+ *
+ * Or import from main entry point (also tree-shakeable):
+ *   import { sqrt, exp, abs } from 'numpy-ts';
+ */
+import { NDArrayCore } from './types';
+/** Add arguments element-wise */
+export declare function add(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Subtract arguments element-wise */
+export declare function subtract(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Multiply arguments element-wise */
+export declare function multiply(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Square root of array elements */
+export declare function sqrt(x: NDArrayCore): NDArrayCore;
+/** Element-wise power */
+export declare function power(x: NDArrayCore, exponent: NDArrayCore | number): NDArrayCore;
+/** Alias for power */
+export declare const pow: typeof power;
+/** Exponential (e^x) */
+export declare function exp(x: NDArrayCore): NDArrayCore;
+/** 2^x */
+export declare function exp2(x: NDArrayCore): NDArrayCore;
+/** exp(x) - 1 */
+export declare function expm1(x: NDArrayCore): NDArrayCore;
+/** Natural logarithm */
+export declare function log(x: NDArrayCore): NDArrayCore;
+/** Base-2 logarithm */
+export declare function log2(x: NDArrayCore): NDArrayCore;
+/** Base-10 logarithm */
+export declare function log10(x: NDArrayCore): NDArrayCore;
+/** log(1 + x) */
+export declare function log1p(x: NDArrayCore): NDArrayCore;
+/** log(exp(x1) + exp(x2)) */
+export declare function logaddexp(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** log2(2^x1 + 2^x2) */
+export declare function logaddexp2(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Absolute value */
+export declare function absolute(x: NDArrayCore): NDArrayCore;
+/** Alias for absolute */
+export declare const abs: typeof absolute;
+/** Numerical negative */
+export declare function negative(x: NDArrayCore): NDArrayCore;
+/** Element-wise sign */
+export declare function sign(x: NDArrayCore): NDArrayCore;
+/** Element-wise modulo */
+export declare function mod(x: NDArrayCore, divisor: NDArrayCore | number): NDArrayCore;
+/** Element-wise division */
+export declare function divide(x: NDArrayCore, divisor: NDArrayCore | number): NDArrayCore;
+/** Alias for divide */
+export declare const true_divide: typeof divide;
+/** Element-wise floor division */
+export declare function floor_divide(x: NDArrayCore, divisor: NDArrayCore | number): NDArrayCore;
+/** Numerical positive (returns copy) */
+export declare function positive(x: NDArrayCore): NDArrayCore;
+/** Reciprocal (1/x) */
+export declare function reciprocal(x: NDArrayCore): NDArrayCore;
+/** Cube root */
+export declare function cbrt(x: NDArrayCore): NDArrayCore;
+/** Absolute value (float) */
+export declare function fabs(x: NDArrayCore): NDArrayCore;
+/** Element-wise divmod (quotient and remainder) */
+export declare function divmod(x: NDArrayCore, y: NDArrayCore | number): [NDArrayCore, NDArrayCore];
+/** Element-wise square */
+export declare function square(x: NDArrayCore): NDArrayCore;
+/** Element-wise remainder */
+export declare function remainder(x: NDArrayCore, y: NDArrayCore | number): NDArrayCore;
+/** Heaviside step function */
+export declare function heaviside(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Float power (always returns float) */
+export declare function float_power(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** C-style fmod */
+export declare function fmod(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Decompose into mantissa and exponent */
+export declare function frexp(x: NDArrayCore): [NDArrayCore, NDArrayCore];
+/** Greatest common divisor */
+export declare function gcd(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Least common multiple */
+export declare function lcm(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Compose from mantissa and exponent */
+export declare function ldexp(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Decompose into fractional and integer parts */
+export declare function modf(x: NDArrayCore): [NDArrayCore, NDArrayCore];
+/** Clip values to a range */
+export declare function clip(a: NDArrayCore, a_min: NDArrayCore | number | null, a_max: NDArrayCore | number | null): NDArrayCore;
+/** Element-wise maximum */
+export declare function maximum(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Element-wise minimum */
+export declare function minimum(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Element-wise maximum (ignores NaN) */
+export declare function fmax(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Element-wise minimum (ignores NaN) */
+export declare function fmin(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Replace NaN/Inf with numbers */
+export declare function nan_to_num(x: NDArrayCore, nan?: number, posinf?: number, neginf?: number): NDArrayCore;
+/** 1D linear interpolation */
+export declare function interp(x: NDArrayCore, xp: NDArrayCore, fp: NDArrayCore, left?: number, right?: number): NDArrayCore;
+/** Unwrap phase angles */
+export declare function unwrap(p: NDArrayCore, discont?: number, axis?: number, period?: number): NDArrayCore;
+/** Sinc function */
+export declare function sinc(x: NDArrayCore): NDArrayCore;
+/** Modified Bessel function of the first kind, order 0 */
+export declare function i0(x: NDArrayCore): NDArrayCore;
+//# sourceMappingURL=arithmetic.d.ts.map

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

@@ -0,0 +1,34 @@
+/**
+ * Bitwise Functions - Tree-shakeable standalone functions
+ *
+ * This module provides bitwise operations that can be
+ * imported independently for optimal tree-shaking.
+ */
+import { NDArrayCore } from './types';
+/** Bitwise AND */
+export declare function bitwise_and(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Bitwise OR */
+export declare function bitwise_or(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Bitwise XOR */
+export declare function bitwise_xor(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Bitwise NOT */
+export declare function bitwise_not(x: NDArrayCore): NDArrayCore;
+/** Bitwise inversion (alias for bitwise_not) */
+export declare function invert(x: NDArrayCore): NDArrayCore;
+/** Left shift */
+export declare function left_shift(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Right shift */
+export declare function right_shift(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Pack bits into bytes */
+export declare function packbits(a: NDArrayCore, axis?: number, bitorder?: 'big' | 'little'): NDArrayCore;
+/** Unpack bytes into bits */
+export declare function unpackbits(a: NDArrayCore, axis?: number, count?: number, bitorder?: 'big' | 'little'): NDArrayCore;
+/** Count number of 1 bits */
+export declare function bitwise_count(x: NDArrayCore): NDArrayCore;
+/** Alias for bitwise_not */
+export declare function bitwise_invert(x: NDArrayCore): NDArrayCore;
+/** Alias for left_shift */
+export declare function bitwise_left_shift(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+/** Alias for right_shift */
+export declare function bitwise_right_shift(x1: NDArrayCore, x2: NDArrayCore | number): NDArrayCore;
+//# sourceMappingURL=bitwise.d.ts.map

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

@@ -1,94 +1,19 @@
 /**
- * Complex number class for numpy-ts
+ * Complex Number Functions - Tree-shakeable standalone functions
  *
- * Represents complex numbers in JavaScript, similar to Python's complex type.
- * Used when converting complex arrays to JavaScript values via toArray().
+ * This module provides complex number operations that can be
+ * imported independently for optimal tree-shaking.
  */
-/**
- * Represents a complex number with real and imaginary parts.
- *
- * @example
- * ```typescript
- * const z = new Complex(1, 2);  // 1 + 2i
- * console.log(z.re);  // 1
- * console.log(z.im);  // 2
- * console.log(z.toString());  // "(1+2j)"
- * ```
- */
-export declare class Complex {
-    /** Real part */
-    readonly re: number;
-    /** Imaginary part */
-    readonly im: number;
-    constructor(re: number, im?: number);
-    /**
-     * Returns the magnitude (absolute value) of the complex number.
-     * |z| = sqrt(re² + im²)
-     */
-    abs(): number;
-    /**
-     * Returns the phase angle (argument) of the complex number in radians.
-     * arg(z) = atan2(im, re)
-     */
-    angle(): number;
-    /**
-     * Returns the complex conjugate.
-     * conj(a + bi) = a - bi
-     */
-    conj(): Complex;
-    /**
-     * Add another complex number or real number.
-     */
-    add(other: Complex | number): Complex;
-    /**
-     * Subtract another complex number or real number.
-     */
-    sub(other: Complex | number): Complex;
-    /**
-     * Multiply by another complex number or real number.
-     * (a + bi)(c + di) = (ac - bd) + (ad + bc)i
-     */
-    mul(other: Complex | number): Complex;
-    /**
-     * Divide by another complex number or real number.
-     * (a + bi) / (c + di) = ((ac + bd) + (bc - ad)i) / (c² + d²)
-     */
-    div(other: Complex | number): Complex;
-    /**
-     * Returns the negation of this complex number.
-     */
-    neg(): Complex;
-    /**
-     * Check equality with another complex number.
-     */
-    equals(other: Complex): boolean;
-    /**
-     * String representation matching NumPy/Python format: "(a+bj)"
-     */
-    toString(): string;
-    /**
-     * Create a Complex from various input formats.
-     * Accepts:
-     * - Complex instance
-     * - {re, im} object
-     * - [re, im] array
-     * - number (creates re + 0i)
-     */
-    static from(value: ComplexInput): Complex;
-    /**
-     * Check if a value is a complex number representation.
-     */
-    static isComplex(value: unknown): value is ComplexInput;
-}
-/**
- * Input types that can be converted to Complex.
- */
-export type ComplexInput = Complex | {
-    re: number;
-    im?: number;
-} | [number, number] | number;
-/**
- * Helper to check if a value looks like a complex number input.
- */
-export declare function isComplexLike(value: unknown): value is ComplexInput;
+import { NDArrayCore } from './types';
+export { Complex } from '../common/complex';
+/** Extract real part of array */
+export declare function real(x: NDArrayCore): NDArrayCore;
+/** Extract imaginary part of array */
+export declare function imag(x: NDArrayCore): NDArrayCore;
+/** Complex conjugate */
+export declare function conj(x: NDArrayCore): NDArrayCore;
+/** Alias for conj */
+export declare const conjugate: typeof conj;
+/** Phase angle */
+export declare function angle(x: NDArrayCore, deg?: boolean): NDArrayCore;
 //# sourceMappingURL=complex.d.ts.map

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

@@ -0,0 +1,98 @@
+/**
+ * Array Creation Functions - Tree-shakeable standalone module
+ *
+ * This module provides all array creation functions including:
+ * - Basic: zeros, ones, empty, full, array, arange, linspace, etc.
+ * - Advanced: diag, tri, meshgrid, vander, etc.
+ *
+ * All functions return NDArrayCore for optimal tree-shaking.
+ */
+import { NDArrayCore, type DType } from '../common/ndarray-core';
+import { type TypedArray } from '../common/dtype';
+export type { DType, TypedArray } from '../common/dtype';
+/**
+ * Create array of zeros
+ */
+export declare function zeros(shape: number[], dtype?: DType): NDArrayCore;
+/**
+ * Create array of ones
+ */
+export declare function ones(shape: number[], dtype?: DType): NDArrayCore;
+/**
+ * Create an uninitialized array (zeros in JS)
+ */
+export declare function empty(shape: number[], dtype?: DType): NDArrayCore;
+/**
+ * Create array filled with a constant value
+ */
+export declare function full(shape: number[], fill_value: number | bigint | boolean, dtype?: DType): NDArrayCore;
+/**
+ * Create array from nested JavaScript arrays
+ */
+export declare function array(data: unknown, dtype?: DType): NDArrayCore;
+/**
+ * Create array with evenly spaced values within a given interval
+ */
+export declare function arange(start: number, stop?: number, step?: number, dtype?: DType): NDArrayCore;
+/**
+ * Create array with evenly spaced values over a specified interval
+ */
+export declare function linspace(start: number, stop: number, num?: number, dtype?: DType): NDArrayCore;
+/**
+ * Create array with logarithmically spaced values
+ */
+export declare function logspace(start: number, stop: number, num?: number, base?: number, dtype?: DType): NDArrayCore;
+/**
+ * Create array with geometrically spaced values
+ */
+export declare function geomspace(start: number, stop: number, num?: number, dtype?: DType): NDArrayCore;
+/**
+ * Create identity matrix
+ */
+export declare function eye(n: number, m?: number, k?: number, dtype?: DType): NDArrayCore;
+/**
+ * Create a square identity matrix
+ */
+export declare function identity(n: number, dtype?: DType): NDArrayCore;
+/**
+ * Convert input to an ndarray
+ */
+export declare function asarray(a: NDArrayCore | unknown, dtype?: DType): NDArrayCore;
+/**
+ * Return array of zeros with the same shape and dtype as input
+ */
+export declare function zeros_like(a: NDArrayCore, dtype?: DType): NDArrayCore;
+/**
+ * Return array of ones with the same shape and dtype as input
+ */
+export declare function ones_like(a: NDArrayCore, dtype?: DType): NDArrayCore;
+/**
+ * Return empty array with the same shape and dtype as input
+ */
+export declare function empty_like(a: NDArrayCore, dtype?: DType): NDArrayCore;
+/**
+ * Return array filled with value, same shape and dtype as input
+ */
+export declare function full_like(a: NDArrayCore, fill_value: number | bigint | boolean, dtype?: DType): NDArrayCore;
+/**
+ * Deep copy of array
+ */
+export declare function copy(a: NDArrayCore): NDArrayCore;
+export declare function asanyarray(a: NDArrayCore | unknown, dtype?: DType): NDArrayCore;
+export declare function ascontiguousarray(a: NDArrayCore | unknown, dtype?: DType): NDArrayCore;
+export declare function asfortranarray(a: NDArrayCore | unknown, dtype?: DType): NDArrayCore;
+export declare function asarray_chkfinite(a: NDArrayCore | unknown, dtype?: DType): NDArrayCore;
+export declare function require(a: NDArrayCore, dtype?: DType, _requirements?: string | string[]): NDArrayCore;
+export declare function diag(v: NDArrayCore, k?: number): NDArrayCore;
+export declare function diagflat(v: NDArrayCore, k?: number): NDArrayCore;
+export declare function tri(N: number, M?: number, k?: number, dtype?: DType): NDArrayCore;
+export declare function tril(m: NDArrayCore, k?: number): NDArrayCore;
+export declare function triu(m: NDArrayCore, k?: number): NDArrayCore;
+export declare function vander(x: NDArrayCore, N?: number, increasing?: boolean): NDArrayCore;
+export declare function frombuffer(buffer: ArrayBuffer | TypedArray, dtype?: DType, count?: number, offset?: number): NDArrayCore;
+export declare function fromfunction(func: (...indices: number[]) => number, shape: number[], dtype?: DType): NDArrayCore;
+export declare function fromiter(iter: Iterable<number>, dtype?: DType, count?: number): NDArrayCore;
+export declare function fromstring(string: string, dtype?: DType, count?: number, sep?: string): NDArrayCore;
+export declare function fromfile(_file: string, _dtype?: DType, _count?: number, _sep?: string): NDArrayCore;
+export declare function meshgrid(...arrays: NDArrayCore[]): NDArrayCore[];
+//# sourceMappingURL=creation.d.ts.map

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

@@ -0,0 +1,29 @@
+/**
+ * Formatting and printing functions
+ *
+ * Tree-shakeable standalone functions that wrap the underlying ops.
+ */
+import { NDArrayCore } from '../common/ndarray-core';
+import * as formattingOps from '../common/ops/formatting';
+export declare const set_printoptions: typeof formattingOps.set_printoptions;
+export declare const get_printoptions: typeof formattingOps.get_printoptions;
+export declare const printoptions: typeof formattingOps.printoptions;
+export declare const format_float_positional: typeof formattingOps.format_float_positional;
+export declare const format_float_scientific: typeof formattingOps.format_float_scientific;
+export declare const base_repr: typeof formattingOps.base_repr;
+export declare const binary_repr: typeof formattingOps.binary_repr;
+export declare function array2string(a: NDArrayCore, options?: {
+    max_line_width?: number;
+    precision?: number;
+    suppress_small?: boolean;
+    separator?: string;
+    prefix?: string;
+    suffix?: string;
+    threshold?: number;
+    edgeitems?: number;
+    sign?: ' ' | '+' | '-';
+    floatmode?: 'fixed' | 'unique' | 'maxprec' | 'maxprec_equal';
+}): string;
+export declare function array_repr(a: NDArrayCore, max_line_width?: number, precision?: number, suppress_small?: boolean): string;
+export declare function array_str(a: NDArrayCore, max_line_width?: number, precision?: number): string;
+//# sourceMappingURL=formatting.d.ts.map

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

@@ -0,0 +1,14 @@
+/**
+ * Gradient and Differentiation Functions - Tree-shakeable standalone functions
+ *
+ * This module provides differentiation operations that can be
+ * imported independently for optimal tree-shaking.
+ */
+import { NDArrayCore } from './types';
+/** Calculate n-th discrete difference */
+export declare function diff(a: NDArrayCore, n?: number, axis?: number): NDArrayCore;
+/** Difference between consecutive elements in 1D array */
+export declare function ediff1d(a: NDArrayCore, to_end?: number[] | null, to_begin?: number[] | null): NDArrayCore;
+/** Return gradient of N-dimensional array */
+export declare function gradient(f: NDArrayCore, varargs?: number | number[], axis?: number | number[] | null): NDArrayCore | NDArrayCore[];
+//# sourceMappingURL=gradient.d.ts.map

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

@@ -0,0 +1,40 @@
+/**
+ * Core Module - Tree-shakeable standalone functions
+ *
+ * This module re-exports all standalone functions from the various
+ * function modules. All functions return NDArrayCore for optimal tree-shaking.
+ *
+ * For optimal tree-shaking, you can also import from specific submodules:
+ *   import { sin, cos } from 'numpy-ts/core/trig';
+ *   import { dot, inv } from 'numpy-ts/core/linalg';
+ */
+export type { DType, TypedArray } from './types';
+export { NDArrayCore, Complex, ArrayStorage } from './types';
+export { zeros, ones, empty, full, array, arange, linspace, logspace, geomspace, eye, identity, asarray, zeros_like, ones_like, empty_like, full_like, copy, asanyarray, ascontiguousarray, asfortranarray, asarray_chkfinite, require, diag, diagflat, tri, tril, triu, vander, frombuffer, fromfunction, fromiter, fromstring, fromfile, meshgrid, } from './creation';
+export { add, subtract, multiply, sqrt, power, pow, exp, exp2, expm1, log, log2, log10, log1p, logaddexp, logaddexp2, absolute, abs, negative, sign, mod, divide, true_divide, floor_divide, positive, reciprocal, cbrt, fabs, divmod, square, remainder, heaviside, float_power, fmod, frexp, gcd, lcm, ldexp, modf, clip, maximum, minimum, fmax, fmin, nan_to_num, interp, unwrap, sinc, i0, } from './arithmetic';
+export { sin, cos, tan, arcsin, asin, arccos, acos, arctan, atan, arctan2, atan2, hypot, degrees, radians, deg2rad, rad2deg, sinh, cosh, tanh, arcsinh, asinh, arccosh, acosh, arctanh, atanh, } from './trig';
+export { dot, matmul, trace, diagonal, kron, transpose, inner, outer, tensordot, einsum, einsum_path, vdot, vecdot, matrix_transpose, permute_dims, matvec, vecmat, cross, linalg, } from './linalg';
+export { reshape, flatten, ravel, squeeze, expand_dims, swapaxes, moveaxis, rollaxis, concatenate, stack, vstack, hstack, dstack, concat, column_stack, row_stack, block, split, array_split, vsplit, hsplit, dsplit, unstack, tile, repeat, flip, fliplr, flipud, rot90, roll, resize, atleast_1d, atleast_2d, atleast_3d, } from './shape';
+export { sum, mean, prod, max, amax, min, amin, ptp, argmin, argmax, variance, var_, variance as var, std, median, percentile, quantile, average, all, any, cumsum, cumulative_sum, cumprod, cumulative_prod, nansum, nanprod, nanmean, nanvar, nanstd, nanmin, nanmax, nanargmin, nanargmax, nancumsum, nancumprod, nanmedian, nanquantile, nanpercentile, } from './reduction';
+export { logical_and, logical_or, logical_not, logical_xor, isfinite, isinf, isnan, isnat, isneginf, isposinf, iscomplex, iscomplexobj, isreal, isrealobj, real_if_close, isfortran, isscalar, iterable, isdtype, promote_types, copysign, signbit, nextafter, spacing, greater, greater_equal, less, less_equal, equal, not_equal, isclose, allclose, } from './logic';
+export { sort, argsort, lexsort, partition, argpartition, sort_complex, nonzero, argwhere, flatnonzero, where, searchsorted, extract, count_nonzero, } from './sorting';
+export { bitwise_and, bitwise_or, bitwise_xor, bitwise_not, invert, left_shift, right_shift, packbits, unpackbits, bitwise_count, bitwise_invert, bitwise_left_shift, bitwise_right_shift, } from './bitwise';
+export { around, round_, round, ceil, fix, floor, rint, trunc } from './rounding';
+export { unique, in1d, intersect1d, isin, setdiff1d, setxor1d, union1d, trim_zeros, unique_all, unique_counts, unique_inverse, unique_values, } from './sets';
+export { bincount, digitize, histogram, histogram2d, histogramdd, correlate, convolve, cov, corrcoef, histogram_bin_edges, trapezoid, } from './statistics';
+export { diff, ediff1d, gradient } from './gradient';
+export { real, imag, conj, conjugate, angle } from './complex';
+export { broadcast_to, broadcast_arrays, broadcast_shapes, take, put, take_along_axis, put_along_axis, choose, compress, select, place, putmask, copyto, indices, ix_, ravel_multi_index, unravel_index, diag_indices, diag_indices_from, fill_diagonal, tril_indices, tril_indices_from, triu_indices, triu_indices_from, mask_indices, array_equal, array_equiv, apply_along_axis, apply_over_axes, may_share_memory, shares_memory, geterr, seterr, iindex, bindex, } from './advanced';
+export { set_printoptions, get_printoptions, printoptions, format_float_positional, format_float_scientific, base_repr, binary_repr, array2string, array_repr, array_str, } from './formatting';
+export { ndim, shape, size, item, tolist, tobytes, byteswap, view, tofile, fill } from './utility';
+export { append, delete_, delete_ as delete, insert, pad } from './shape-extra';
+export { can_cast, common_type, result_type, min_scalar_type, issubdtype, typename, mintypecode, } from './typechecking';
+export { poly, polyadd, polyder, polydiv, polyfit, polyint, polymul, polysub, polyval, roots, } from './polynomial';
+export { parseNpy, parseNpyHeader, parseNpyData } from '../io/npy/parser';
+export { serializeNpy } from '../io/npy/serializer';
+export { UnsupportedDTypeError, InvalidNpyError, SUPPORTED_DTYPES, DTYPE_TO_DESCR, type NpyHeader, type NpyMetadata, type NpyVersion, } from '../io/npy/format';
+export { parseNpz, parseNpzSync, loadNpz, loadNpzSync, type NpzParseOptions, type NpzParseResult, } from '../io/npz/parser';
+export { serializeNpz, serializeNpzSync, type NpzArraysInput, type NpzSerializeOptions, } from '../io/npz/serializer';
+export { parseTxt, genfromtxt, fromregex, type ParseTxtOptions } from '../io/txt/parser';
+export { serializeTxt, type SerializeTxtOptions } from '../io/txt/serializer';
+//# sourceMappingURL=index.d.ts.map