numpy-ts 0.12.0 → 0.13.0

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

@@ -0,0 +1,94 @@
+/**
+ * Complex number class for numpy-ts
+ *
+ * Represents complex numbers in JavaScript, similar to Python's complex type.
+ * Used when converting complex arrays to JavaScript values via toArray().
+ */
+/**
+ * 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;
+//# sourceMappingURL=complex.d.ts.map

package/dist/types/{internal → common/internal}/compute.d.ts

@@ -6,7 +6,7 @@
  *
  * @internal
  */
-import { ArrayStorage } from '../core/storage';
+import { ArrayStorage } from '../storage';
 /**
  * Compute the broadcast shape of two arrays
  * Returns the shape that results from broadcasting a and b together

package/dist/types/{internal → common/internal}/indexing.d.ts

@@ -10,6 +10,12 @@ export declare function computeStrides(shape: readonly number[]): number[];
  * Convert multi-index to linear index in row-major order
  */
 export declare function multiIndexToLinear(indices: number[], shape: readonly number[]): number;
+/**
+ * Convert multi-index to buffer position using actual strides and offset.
+ * Unlike multiIndexToLinear (which assumes C-contiguous layout),
+ * this works correctly for non-contiguous views/slices.
+ */
+export declare function multiIndexToBuffer(indices: number[], strides: readonly number[], offset: number): number;
 /**
  * Convert outer index and axis index to full multi-index
  * Used in reductions along a specific axis

package/dist/types/common/ndarray-core.d.ts

@@ -0,0 +1,126 @@
+/**
+ * NDArray Core - Minimal NDArray class for tree-shaking
+ *
+ * This module contains the minimal NDArray class without operation methods.
+ * It only depends on core modules (storage, dtype, slicing, complex) and
+ * does NOT import any ops modules.
+ *
+ * For the full NDArray with all methods, use ndarray-full.ts
+ */
+import { type DType, type TypedArray } from './dtype';
+import { Complex } from './complex';
+import { ArrayStorage } from './storage';
+/**
+ * Minimal NDArray class - core functionality without operation methods
+ *
+ * This class provides:
+ * - Array properties (shape, dtype, data, etc.)
+ * - Element access (get, set, iget, iset)
+ * - Basic methods (copy, astype, fill, slice)
+ * - Conversion methods (toArray, tolist, tobytes)
+ *
+ * Operation methods (add, sin, reshape, etc.) are NOT included.
+ * Use NDArray from ndarray-full.ts for the complete API.
+ */
+export declare class NDArrayCore {
+    protected _storage: ArrayStorage;
+    protected _base?: NDArrayCore;
+    constructor(storage: ArrayStorage, base?: NDArrayCore);
+    /**
+     * Get internal storage (for ops modules)
+     * @internal
+     */
+    get storage(): ArrayStorage;
+    /**
+     * Create NDArray from storage (for ops modules)
+     * @internal
+     */
+    static fromStorage(storage: ArrayStorage, base?: NDArrayCore): NDArrayCore;
+    get shape(): readonly number[];
+    get ndim(): number;
+    get size(): number;
+    get dtype(): string;
+    get data(): TypedArray;
+    get strides(): readonly number[];
+    /**
+     * Array flags (similar to NumPy's flags)
+     */
+    get flags(): {
+        C_CONTIGUOUS: boolean;
+        F_CONTIGUOUS: boolean;
+        OWNDATA: boolean;
+    };
+    /**
+     * Base array if this is a view, null if this array owns its data
+     */
+    get base(): NDArrayCore | null;
+    /**
+     * Size of one array element in bytes
+     */
+    get itemsize(): number;
+    /**
+     * Total bytes consumed by the elements of the array
+     */
+    get nbytes(): number;
+    /**
+     * Fill the array with a scalar value (in-place)
+     */
+    fill(value: number | bigint): void;
+    /**
+     * Iterator protocol - iterate over the first axis
+     */
+    [Symbol.iterator](): Iterator<NDArrayCore | number | bigint | Complex>;
+    /**
+     * Get a single element from the array
+     */
+    get(indices: number[]): number | bigint | Complex;
+    /**
+     * Set a single element in the array
+     */
+    set(indices: number[], value: number | bigint | Complex | {
+        re: number;
+        im: number;
+    }): void;
+    /**
+     * Get element by flat index
+     */
+    iget(flatIndex: number): number | bigint | Complex;
+    /**
+     * Set element by flat index
+     */
+    iset(flatIndex: number, value: number | bigint | Complex): void;
+    /**
+     * Return a deep copy of the array
+     */
+    copy(): NDArrayCore;
+    /**
+     * Cast array to a different dtype
+     */
+    astype(dtype: DType, copy?: boolean): NDArrayCore;
+    /**
+     * Slice the array
+     */
+    slice(...sliceStrs: string[]): NDArrayCore;
+    /**
+     * String representation
+     */
+    toString(): string;
+    /**
+     * Convert to nested JavaScript array
+     */
+    toArray(): unknown;
+    /**
+     * Return the array as a nested list (same as toArray)
+     */
+    tolist(): unknown;
+    /**
+     * Return the raw bytes of the array data
+     */
+    tobytes(): ArrayBuffer;
+    /**
+     * Copy an element of an array to a standard scalar and return it
+     */
+    item(...args: number[]): number | bigint | Complex;
+}
+export type { DType, TypedArray };
+//# sourceMappingURL=ndarray-core.d.ts.map

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

@@ -4,8 +4,8 @@
  * Broadcasting, indexing, and comparison functions.
  * @module ops/advanced
  */
-import { ArrayStorage } from '../core/storage';
-import { broadcastShapes } from '../core/broadcasting';
+import { ArrayStorage } from '../storage';
+import { broadcastShapes } from '../broadcasting';
 /**
  * Broadcast an array to a given shape
  * Returns a read-only view on the original array

package/dist/types/{ops → common/ops}/arithmetic.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';
 /**
  * Add two arrays or array and scalar
  *

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

@@ -7,7 +7,7 @@
  *
  * These operations only work on integer types.
  */
-import { ArrayStorage } from '../core/storage';
+import { ArrayStorage } from '../storage';
 /**
  * Bitwise AND of two arrays or array and scalar
  *

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

@@ -5,7 +5,7 @@
  * greater, greater_equal, less, less_equal, equal, not_equal,
  * isclose, allclose
  */
-import { ArrayStorage } from '../core/storage';
+import { ArrayStorage } from '../storage';
 /**
  * Element-wise greater than comparison (a > b)
  * For complex: uses lexicographic ordering (real first, then imaginary)

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

@@ -6,7 +6,7 @@
  *
  * @module ops/complex
  */
-import { ArrayStorage } from '../core/storage';
+import { ArrayStorage } from '../storage';
 /**
  * Return the real part of complex argument.
  *

package/dist/types/{ops → common/ops}/exponential.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';
 /**
  * Square root of each element
  * NumPy behavior: Always promotes to float64 for integer types

package/dist/types/common/ops/fft.d.ts

@@ -0,0 +1,166 @@
+/**
+ * FFT (Fast Fourier Transform) operations
+ *
+ * Implements NumPy's np.fft module:
+ * - fft, ifft: 1D FFT
+ * - fft2, ifft2: 2D FFT
+ * - fftn, ifftn: N-dimensional FFT
+ * - rfft, irfft: Real FFT
+ * - rfft2, irfft2: 2D Real FFT
+ * - rfftn, irfftn: N-dimensional Real FFT
+ * - hfft, ihfft: Hermitian FFT
+ * - fftfreq, rfftfreq: FFT frequencies
+ * - fftshift, ifftshift: Shift zero-frequency to center
+ *
+ * @module ops/fft
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * Compute the 1-D discrete Fourier Transform.
+ *
+ * @param a - Input array storage
+ * @param n - Length of the transformed axis (default: length of a)
+ * @param axis - Axis along which to compute the FFT (default: -1, last axis)
+ * @param norm - Normalization mode: 'backward', 'ortho', or 'forward' (default: 'backward')
+ * @returns Complex array containing the FFT result
+ */
+export declare function fft(a: ArrayStorage, n?: number, axis?: number, norm?: 'backward' | 'ortho' | 'forward'): ArrayStorage;
+/**
+ * Compute the 1-D inverse discrete Fourier Transform.
+ *
+ * @param a - Input array storage
+ * @param n - Length of the transformed axis (default: length of a)
+ * @param axis - Axis along which to compute the IFFT (default: -1, last axis)
+ * @param norm - Normalization mode: 'backward', 'ortho', or 'forward' (default: 'backward')
+ * @returns Complex array containing the IFFT result
+ */
+export declare function ifft(a: ArrayStorage, n?: number, axis?: number, norm?: 'backward' | 'ortho' | 'forward'): ArrayStorage;
+/**
+ * Compute the 2-D discrete Fourier Transform.
+ *
+ * @param a - Input array storage
+ * @param s - Shape of the output (default: shape of input along axes)
+ * @param axes - Axes along which to compute the FFT (default: [-2, -1])
+ * @param norm - Normalization mode
+ * @returns Complex array containing the FFT result
+ */
+export declare function fft2(a: ArrayStorage, s?: [number, number], axes?: [number, number], norm?: 'backward' | 'ortho' | 'forward'): ArrayStorage;
+/**
+ * Compute the 2-D inverse discrete Fourier Transform.
+ *
+ * @param a - Input array storage
+ * @param s - Shape of the output
+ * @param axes - Axes along which to compute the IFFT
+ * @param norm - Normalization mode
+ * @returns Complex array containing the IFFT result
+ */
+export declare function ifft2(a: ArrayStorage, s?: [number, number], axes?: [number, number], norm?: 'backward' | 'ortho' | 'forward'): ArrayStorage;
+/**
+ * Compute the N-D discrete Fourier Transform.
+ *
+ * @param a - Input array storage
+ * @param s - Shape of the output along transform axes
+ * @param axes - Axes along which to compute the FFT
+ * @param norm - Normalization mode
+ * @returns Complex array containing the FFT result
+ */
+export declare function fftn(a: ArrayStorage, s?: number[], axes?: number[], norm?: 'backward' | 'ortho' | 'forward'): ArrayStorage;
+/**
+ * Compute the N-D inverse discrete Fourier Transform.
+ *
+ * @param a - Input array storage
+ * @param s - Shape of the output along transform axes
+ * @param axes - Axes along which to compute the IFFT
+ * @param norm - Normalization mode
+ * @returns Complex array containing the IFFT result
+ */
+export declare function ifftn(a: ArrayStorage, s?: number[], axes?: number[], norm?: 'backward' | 'ortho' | 'forward'): ArrayStorage;
+/**
+ * Compute the 1-D FFT of a real-valued array.
+ *
+ * @param a - Input array storage (real-valued)
+ * @param n - Length of the transformed axis
+ * @param axis - Axis along which to compute the FFT
+ * @param norm - Normalization mode
+ * @returns Complex array with length n//2 + 1 along the transformed axis
+ */
+export declare function rfft(a: ArrayStorage, n?: number, axis?: number, norm?: 'backward' | 'ortho' | 'forward'): ArrayStorage;
+/**
+ * Compute the inverse of rfft.
+ *
+ * @param a - Input array storage (from rfft)
+ * @param n - Length of the output along the transformed axis
+ * @param axis - Axis along which to compute the IFFT
+ * @param norm - Normalization mode
+ * @returns Real array
+ */
+export declare function irfft(a: ArrayStorage, n?: number, axis?: number, norm?: 'backward' | 'ortho' | 'forward'): ArrayStorage;
+/**
+ * Compute the 2-D FFT of a real-valued array.
+ */
+export declare function rfft2(a: ArrayStorage, s?: [number, number], axes?: [number, number], norm?: 'backward' | 'ortho' | 'forward'): ArrayStorage;
+/**
+ * Compute the inverse of rfft2.
+ */
+export declare function irfft2(a: ArrayStorage, s?: [number, number], axes?: [number, number], norm?: 'backward' | 'ortho' | 'forward'): ArrayStorage;
+/**
+ * Compute the N-D FFT of a real-valued array.
+ */
+export declare function rfftn(a: ArrayStorage, s?: number[], axes?: number[], norm?: 'backward' | 'ortho' | 'forward'): ArrayStorage;
+/**
+ * Compute the inverse of rfftn.
+ */
+export declare function irfftn(a: ArrayStorage, s?: number[], axes?: number[], norm?: 'backward' | 'ortho' | 'forward'): ArrayStorage;
+/**
+ * Compute the FFT of a signal with Hermitian symmetry (real spectrum).
+ *
+ * @param a - Input array with Hermitian symmetry
+ * @param n - Length of the output
+ * @param axis - Axis along which to compute
+ * @param norm - Normalization mode
+ * @returns Real array
+ */
+export declare function hfft(a: ArrayStorage, n?: number, axis?: number, norm?: 'backward' | 'ortho' | 'forward'): ArrayStorage;
+/**
+ * Compute the inverse of hfft.
+ *
+ * @param a - Input real array
+ * @param n - Length of the Hermitian output
+ * @param axis - Axis along which to compute
+ * @param norm - Normalization mode
+ * @returns Complex array with Hermitian symmetry
+ */
+export declare function ihfft(a: ArrayStorage, n?: number, axis?: number, norm?: 'backward' | 'ortho' | 'forward'): ArrayStorage;
+/**
+ * Return the Discrete Fourier Transform sample frequencies.
+ *
+ * @param n - Window length
+ * @param d - Sample spacing (default: 1.0)
+ * @returns Array of length n containing the sample frequencies
+ */
+export declare function fftfreq(n: number, d?: number): ArrayStorage;
+/**
+ * Return the Discrete Fourier Transform sample frequencies for rfft.
+ *
+ * @param n - Window length
+ * @param d - Sample spacing (default: 1.0)
+ * @returns Array of length n//2 + 1 containing the sample frequencies
+ */
+export declare function rfftfreq(n: number, d?: number): ArrayStorage;
+/**
+ * Shift the zero-frequency component to the center of the spectrum.
+ *
+ * @param a - Input array
+ * @param axes - Axes over which to shift (default: all axes)
+ * @returns Shifted array
+ */
+export declare function fftshift(a: ArrayStorage, axes?: number | number[]): ArrayStorage;
+/**
+ * Inverse of fftshift.
+ *
+ * @param a - Input array
+ * @param axes - Axes over which to shift (default: all axes)
+ * @returns Shifted array
+ */
+export declare function ifftshift(a: ArrayStorage, axes?: number | number[]): ArrayStorage;
+//# sourceMappingURL=fft.d.ts.map