Bit-reverse an index.

Generate Blackman window. `w[n] = 0.42 - 0.5*cos(2πn/(N-1)) + 0.08*cos(4πn/(N-1))`

Cooley-Tukey DIT butterfly with precomputed twiddle factors. `tw` contains the powers of the root of unity: tw[i] = ω^i for i = 0..n/2.

Get a reference to the communicator.

Compute the complex cepstrum of a signal. The complex cepstrum is defined as `IFFT(log(FFT(x)))` where `log` is the complex logarithm with phase unwr

Raise a complex f64 number `z` to a real power `p` (polar form).

Compute input and output offsets for a given batch index.

Brute-force DFT of the current circular buffer (called once).

Compute circular convolution (wraps around).

Compute linear convolution of complex signals with specified mode.

Compute cross-correlation of two signals. Correlation is similar to convolution but without reversing b: `(a ⋆ b)[n] = Σ_k a[k] * conj(b[k-n])` For

Count subexpression usages (bottom-up traversal).

Detect the format version encoded in a wisdom string. Accepts both the legacy `(oxifft-wisdom-1.0 …)` header (returns 0) and the current `(oxifft-wis

Compute expected output using Direct O(n²) algorithm.

Direct DFT computation for sparse input. Complexity: O(K * N) where K is number of non-zero inputs.

DIF butterfly stages. Uses twiddle recurrence to avoid repeated sin/cos calls.

DIT butterfly stages.

Radix-4 DIT butterfly stages. After standard bit-reversal, we can perform radix-4 butterflies that combine two radix-2 stages into one, reducing the

Radix-8 DIT butterfly stages. Combines three radix-2 stages into one radix-8 stage. For log_n not divisible by 3, uses radix-2 and/or radix-4 for rem

Convenience function for DST-I transform.

Emit a constant value as `T::ZERO`, `T::ONE`, `(-T::ONE)`, or `T::from_f64(v)`.

Emit a scalar `Expr` for HC2R (complex inputs `y{k}_re` / `y{k}_im`).

Initialize global wisdom if not already initialized.

Compute the envelope (instantaneous amplitude) of a real signal. Returns `|analytic_signal[i]|` for each sample, where `analytic_signal` is the resul

Execute the distributed FFT out-of-place. # Errors Returns `MpiError::SizeMismatch` if input buffer is too small.

Execute the distributed FFT out-of-place. # Errors Returns `MpiError::SizeMismatch` if input buffer is too small.

Execute the transform on split-complex input/output. # Arguments `in_real` - Input real parts `in_imag` - Input imaginary parts `out_real` - Output r

Execute using Bluestein for arbitrary sizes.

Execute DCT-I transform (dispatches to fast for n >= 16, direct otherwise).

Execute DCT-IV transform (dispatches to fast for n >= 16, direct otherwise).

Execute Discrete Hartley Transform (dispatches to fast for n >= 16, direct otherwise). The DHT is its own inverse (up to scaling by N), making it par

Execute DST-I transform (dispatches to fast for n >= 16, direct otherwise).

Execute DST-II transform (dispatches to fast for n >= 16, direct otherwise).

Execute DST-III transform (dispatches to fast for n >= 16, direct otherwise).

Execute DST-IV transform (dispatches to fast for n >= 16, direct otherwise).

Execute FFT in-place with gather/scatter for non-contiguous data.

Execute FFT in-place with buffering.

Execute in-place Bluestein FFT. Uses the pre-allocated `work_inplace` buffer when available (avoids an unconditional `data.to_vec()` allocation in th

Execute a single in-place transform.

Execute the mixed-radix DIT FFT in-place on `data`. `factors` is ordered innermost-first. After digit-reversal permutation, each stage applies the co

Execute batched R2C (real-to-complex) FFT. For each batch, takes n real values and produces n/2+1 complex values. # Arguments `input` - Input buffer

Execute a single transform at the given offsets.

Apply a 3D FFT via three sequential 1D passes in Z -> Y -> X order, using pre-created `Plan` instances. Input/output layout: row-major `[n0][n1][n2]`

Compute full FFT and select specific outputs.

Convenience function for parallel batched 1D forward FFT. Performs `howmany` independent 1D FFTs, each of size `n`, in parallel. Input and output are

Full FFT from sparse input. First creates full input array, then uses standard FFT.

Convenience function for parallel N-dimensional forward FFT. Input is in row-major order.

Import wisdom from a string. Corresponds to FFTW's `fftw_import_wisdom_from_string`. Returns `true` on success, `false` if the string is malformed o

FFT sizes fit in f64 mantissa

Fixed inputs for shuffle-rewrite parity (bitwise-exact expected).

Execute forward FFT. # Arguments `real` - Real part of input (length must equal size) `imag` - Imaginary part of input (length must equal size) # R

Compute forward FFT with its Jacobian-vector product (forward mode AD). Given input x and tangent dx, computes: - y = FFT(x) - dy = FFT(dx) (the dire

Convert from `num_complex::Complex` to oxifft Complex.

Convert from num_complex::Complex to oxifft Complex.

Gather elements from strided source into contiguous destination.

Generate `m` non-uniform points in `(-π, π)`, clamped away from the boundary to avoid fp-rounding ejection by the range guard in `Nufft::new`.

Generate `n` complex values with components in `[-1, 1]`.

Generate coprime factors for CRT. Returns a set of small coprime numbers whose product is at least target.

Generate test input data.