numpy-ts 0.11.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
@@ -112,4 +112,69 @@ export declare function unravel_index(indices: ArrayStorage | number, shape: num
  * @param wrap - Whether to wrap for tall matrices
  */
 export declare function fill_diagonal(a: ArrayStorage, val: ArrayStorage | number, wrap?: boolean): void;
+/**
+ * Apply a function along a given axis.
+ *
+ * @param arr - Input array storage
+ * @param axis - Axis along which to apply the function
+ * @param func1d - Function that takes a 1D array and returns a 1D array or scalar
+ * @returns Result array
+ */
+export declare function apply_along_axis(arr: ArrayStorage, axis: number, func1d: (slice: ArrayStorage) => ArrayStorage | number): ArrayStorage;
+/**
+ * Apply a function over multiple axes.
+ *
+ * @param arr - Input array storage
+ * @param func - Function that operates on an array
+ * @param axes - Axes over which to apply the function
+ * @returns Result array
+ */
+export declare function apply_over_axes(arr: ArrayStorage, func: (a: ArrayStorage, axis: number) => ArrayStorage, axes: number[]): ArrayStorage;
+/**
+ * Check if two arrays may share memory.
+ *
+ * In JavaScript, we can't directly check memory sharing like in Python.
+ * This is a conservative implementation that returns true if they share
+ * the same underlying buffer.
+ *
+ * @param a - First array storage
+ * @param b - Second array storage
+ * @returns True if arrays may share memory
+ */
+export declare function may_share_memory(a: ArrayStorage, b: ArrayStorage): boolean;
+/**
+ * Check if two arrays share memory.
+ *
+ * This is the same as may_share_memory in our implementation since
+ * JavaScript doesn't have the same memory model as Python/NumPy.
+ *
+ * @param a - First array storage
+ * @param b - Second array storage
+ * @returns True if arrays share memory
+ */
+export declare function shares_memory(a: ArrayStorage, b: ArrayStorage): boolean;
+type ErrorMode = 'ignore' | 'warn' | 'raise' | 'call' | 'print' | 'log';
+export interface FloatErrorState {
+    divide: ErrorMode;
+    over: ErrorMode;
+    under: ErrorMode;
+    invalid: ErrorMode;
+}
+/**
+ * Get the current floating-point error handling.
+ *
+ * @returns Current error handling settings
+ */
+export declare function geterr(): FloatErrorState;
+/**
+ * Set how floating-point errors are handled.
+ *
+ * @param all - Set all error modes at once (optional)
+ * @param divide - Treatment for division by zero
+ * @param over - Treatment for floating-point overflow
+ * @param under - Treatment for floating-point underflow
+ * @param invalid - Treatment for invalid floating-point operation
+ * @returns Previous error handling settings
+ */
+export declare function seterr(all?: ErrorMode, divide?: ErrorMode, over?: ErrorMode, under?: ErrorMode, invalid?: ErrorMode): FloatErrorState;
 //# sourceMappingURL=advanced.d.ts.map

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
  *
@@ -212,4 +212,103 @@ export declare function ldexp(x1: ArrayStorage, x2: ArrayStorage | number): Arra
  * @returns Tuple of [fractional, integral] arrays
  */
 export declare function modf(x: ArrayStorage): [ArrayStorage, ArrayStorage];
+/**
+ * Clip (limit) the values in an array
+ * Given an interval, values outside the interval are clipped to the interval edges.
+ *
+ * @param a - Input array storage
+ * @param a_min - Minimum value (null to not clip minimum)
+ * @param a_max - Maximum value (null to not clip maximum)
+ * @returns Clipped array storage
+ */
+export declare function clip(a: ArrayStorage, a_min: number | ArrayStorage | null, a_max: number | ArrayStorage | null): ArrayStorage;
+/**
+ * Element-wise maximum of array elements
+ *
+ * @param x1 - First array storage
+ * @param x2 - Second array storage or scalar
+ * @returns Element-wise maximum
+ */
+export declare function maximum(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
+/**
+ * Element-wise minimum of array elements
+ *
+ * @param x1 - First array storage
+ * @param x2 - Second array storage or scalar
+ * @returns Element-wise minimum
+ */
+export declare function minimum(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
+/**
+ * Element-wise maximum of array elements, ignoring NaNs
+ *
+ * @param x1 - First array storage
+ * @param x2 - Second array storage or scalar
+ * @returns Element-wise maximum, NaN-aware
+ */
+export declare function fmax(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
+/**
+ * Element-wise minimum of array elements, ignoring NaNs
+ *
+ * @param x1 - First array storage
+ * @param x2 - Second array storage or scalar
+ * @returns Element-wise minimum, NaN-aware
+ */
+export declare function fmin(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
+/**
+ * Replace NaN with zero and Inf with large finite numbers
+ *
+ * @param x - Input array storage
+ * @param nan - Value to replace NaN (default: 0.0)
+ * @param posinf - Value to replace positive infinity (default: largest finite)
+ * @param neginf - Value to replace negative infinity (default: most negative finite)
+ * @returns Array with replacements
+ */
+export declare function nan_to_num(x: ArrayStorage, nan?: number, posinf?: number, neginf?: number): ArrayStorage;
+/**
+ * One-dimensional linear interpolation
+ *
+ * Returns the one-dimensional piecewise linear interpolant to a function
+ * with given discrete data points (xp, fp), evaluated at x.
+ *
+ * @param x - The x-coordinates at which to evaluate the interpolated values
+ * @param xp - The x-coordinates of the data points (must be increasing)
+ * @param fp - The y-coordinates of the data points
+ * @param left - Value for x < xp[0] (default: fp[0])
+ * @param right - Value for x > xp[-1] (default: fp[-1])
+ * @returns Interpolated values
+ */
+export declare function interp(x: ArrayStorage, xp: ArrayStorage, fp: ArrayStorage, left?: number, right?: number): ArrayStorage;
+/**
+ * Unwrap by changing deltas between values to 2*pi complement
+ *
+ * Unwrap radian phase p by changing absolute jumps greater than
+ * discont to their 2*pi complement along the given axis.
+ *
+ * @param p - Input array of phase angles in radians
+ * @param discont - Maximum discontinuity between values (default: pi)
+ * @param axis - Axis along which to unwrap (default: -1, last axis)
+ * @param period - Size of the range over which the input wraps (default: 2*pi)
+ * @returns Unwrapped array
+ */
+export declare function unwrap(p: ArrayStorage, discont?: number, axis?: number, period?: number): ArrayStorage;
+/**
+ * Return the normalized sinc function
+ *
+ * sinc(x) = sin(pi*x) / (pi*x)
+ *
+ * The sinc function is 1 at x = 0, and sin(pi*x)/(pi*x) otherwise.
+ *
+ * @param x - Input array
+ * @returns Array of sinc values
+ */
+export declare function sinc(x: ArrayStorage): ArrayStorage;
+/**
+ * Modified Bessel function of the first kind, order 0
+ *
+ * Uses polynomial approximation.
+ *
+ * @param x - Input array
+ * @returns Array of I0 values
+ */
+export declare function i0(x: ArrayStorage): ArrayStorage;
 //# sourceMappingURL=arithmetic.d.ts.map

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
  *
@@ -88,4 +88,34 @@ export declare function packbits(a: ArrayStorage, axis?: number, bitorder?: 'big
  * @returns Unpacked uint8 array of 0s and 1s
  */
 export declare function unpackbits(a: ArrayStorage, axis?: number, count?: number, bitorder?: 'big' | 'little'): ArrayStorage;
+/**
+ * Count the number of 1-bits in each element (population count).
+ *
+ * @param x - Input array (must be integer type)
+ * @returns Array with population count for each element
+ */
+export declare function bitwise_count(x: ArrayStorage): ArrayStorage;
+/**
+ * Bitwise invert (alias for bitwise_not)
+ *
+ * @param x - Input array (must be integer type)
+ * @returns Result storage with bitwise NOT values
+ */
+export declare function bitwise_invert(x: ArrayStorage): ArrayStorage;
+/**
+ * Bitwise left shift (alias for left_shift)
+ *
+ * @param x1 - Input array (must be integer type)
+ * @param x2 - Shift amount (array or scalar)
+ * @returns Result storage with left-shifted values
+ */
+export declare function bitwise_left_shift(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
+/**
+ * Bitwise right shift (alias for right_shift)
+ *
+ * @param x1 - Input array (must be integer type)
+ * @param x2 - Shift amount (array or scalar)
+ * @returns Result storage with right-shifted values
+ */
+export declare function bitwise_right_shift(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
 //# sourceMappingURL=bitwise.d.ts.map

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