/**
 * Fast Fourier Transform (FFT)
 *
 * Implements the Cooley-Tukey radix-2 decimation-in-time FFT algorithm.
 * For non-power-of-2 lengths, zero-pads to next power of 2.
 *
 * @packageDocumentation
 */
/**
 * Complex number representation for FFT
 */
export interface ComplexNumber {
    re: number;
    im: number;
}
/**
 * FFT result containing the frequency spectrum
 */
export interface FFTResult {
    /** Complex frequency components */
    spectrum: ComplexNumber[];
    /** Original signal length before padding */
    originalLength: number;
    /** Padded length (power of 2) */
    paddedLength: number;
}
/**
 * Create a complex number
 */
export declare function complex(re: number, im?: number): ComplexNumber;
/**
 * Complex conjugate
 */
export declare function complexConj(a: ComplexNumber): ComplexNumber;
/**
 * Complex magnitude
 */
export declare function complexAbs(a: ComplexNumber): number;
/**
 * Complex phase/argument
 */
export declare function complexArg(a: ComplexNumber): number;
/**
 * Compute the Fast Fourier Transform of a real or complex signal.
 *
 * Uses the Cooley-Tukey radix-2 decimation-in-time algorithm.
 * Input is zero-padded to the next power of 2 if necessary.
 *
 * @param signal - Input signal (real numbers or complex numbers)
 * @returns FFT result with spectrum and length info
 *
 * @example
 * ```typescript
 * // FFT of a real signal
 * const signal = [1, 0, -1, 0];
 * const result = fft(signal);
 * console.log(result.spectrum); // Frequency components
 *
 * // FFT of a complex signal
 * const complexSignal = [
 *   { re: 1, im: 0 },
 *   { re: 0, im: 1 },
 * ];
 * const result2 = fft(complexSignal);
 * ```
 */
export declare function fft(signal: number[] | Float64Array | ComplexNumber[]): FFTResult;
/**
 * Compute the Inverse Fast Fourier Transform.
 *
 * Recovers the time-domain signal from its frequency spectrum.
 *
 * @param spectrum - Complex frequency spectrum
 * @param originalLength - Optional: truncate result to this length
 * @returns Recovered signal
 *
 * @example
 * ```typescript
 * // Round-trip test
 * const signal = [1, 2, 3, 4];
 * const result = fft(signal);
 * const recovered = ifft(result.spectrum, result.originalLength);
 * // recovered ≈ signal
 * ```
 */
export declare function ifft(spectrum: ComplexNumber[], originalLength?: number): ComplexNumber[];
/**
 * Compute the real part of IFFT result
 */
export declare function ifftReal(spectrum: ComplexNumber[], originalLength?: number): number[];
/**
 * Compute the magnitude spectrum (|X(k)|)
 */
export declare function fftMagnitude(spectrum: ComplexNumber[]): number[];
/**
 * Compute the power spectrum (|X(k)|²)
 */
export declare function fftPower(spectrum: ComplexNumber[]): number[];
/**
 * Compute the phase spectrum (arg(X(k)))
 */
export declare function fftPhase(spectrum: ComplexNumber[]): number[];
/**
 * Compute FFT frequency bins for a given sample rate
 *
 * @param n - Number of FFT points
 * @param sampleRate - Sample rate in Hz
 * @returns Array of frequencies in Hz
 */
export declare function fftFrequencies(n: number, sampleRate?: number): number[];
/**
 * Compute the 2D FFT of a matrix
 *
 * @param matrix - 2D array of real or complex values
 * @returns 2D frequency spectrum
 */
export declare function fft2(matrix: number[][] | ComplexNumber[][]): ComplexNumber[][];
/**
 * Compute the 2D inverse FFT
 *
 * @param spectrum - 2D frequency spectrum
 * @returns 2D spatial domain result
 */
export declare function ifft2(spectrum: ComplexNumber[][]): ComplexNumber[][];
/**
 * The single roll algorithm shared by every fftshift/ifftshift surface in the
 * package (the generic `<T>` toolkit members below and the public `number[]`
 * helpers in `./fft-helpers.ts` both route through this). Rotates `arr` left by
 * `count`: the first `count` elements move to the end. numpy.fft uses
 * `floor(n/2)` for fftshift and `ceil(n/2)` for ifftshift so the two are exact
 * inverses on odd lengths.
 */
export declare function rollBy<T>(arr: T[], count: number): T[];
/**
 * Shift zero-frequency component to center of spectrum
 *
 * @param spectrum - FFT spectrum
 * @returns Shifted spectrum
 */
export declare function fftshift<T>(spectrum: T[]): T[];
/**
 * Inverse of fftshift
 */
export declare function ifftshift<T>(spectrum: T[]): T[];
//# sourceMappingURL=fft.d.ts.map