Migrating from fftwtools

Two conventions to know

Scaling. fftwtools, like stats::fft(), never scales: an inverse after a forward transform multiplies by the length. zufft follows scipy.fft and divides the inverse by the length by default (norm = "backward"). Use norm = "none" to get fftwtools’ numbers exactly.

x <- c(1, 4, 2, 8, 5, 7)
fft_c2c(fft_c2c(x), inverse = TRUE)                 # x again
#> [1] 1+0i 4+0i 2+0i 8+0i 5+0i 7+0i
fft_c2c(fft_c2c(x), inverse = TRUE, norm = "none")  # 6 * x, as fftwtools
#> [1]  6+0i 24+0i 12+0i 48+0i 30+0i 42+0i

Half spectra. fftwtools’ HermConj = 1 (its default) returns the full spectrum of real input, and HermConj = 0 the non-redundant half. In zufft that is the choice between fft_c2c() and fft_r2c().

fft_c2c(x)  # full spectrum, as fftw(x) and fftw_r2c(x)
#> [1]  27+0.000000e+00i  -5+5.196152e+00i   0+4.440892e-16i -11+0.000000e+00i
#> [5]   0-4.440892e-16i  -5-5.196152e+00i
fft_r2c(x)  # first n %/% 2 + 1 values, as fftw_r2c(x, HermConj = 0)
#> [1]  27+0.000000e+00i  -5+5.196152e+00i   0+4.440892e-16i -11+0.000000e+00i

To go back from a half spectrum you need the original length, because an even and an odd length give the same half size. Both packages take it as n:

X <- fft_r2c(1:7)
fft_c2r(X, n = 7, norm = "none")   # as fftw_c2r(X, HermConj = 0, n = 7)
#> [1]  7 14 21 28 35 42 49

One-dimensional transforms

inverse = 0 and inverse = 1 work in zufft too.

z <- complex(real = rnorm(8), imaginary = rnorm(8))
all.equal(fft_c2c(z, inverse = 1, norm = "none"), fftwtools::fftw_c2c(z, inverse = 1))
#> [1] TRUE
all.equal(fft_r2c(x), fftwtools::fftw_r2c(x, HermConj = 0))
#> [1] TRUE
all.equal(fft_c2r(X, n = 7, norm = "none"), fftwtools::fftw_c2r(X, HermConj = 0, n = 7))
#> [1] TRUE

Columns of a matrix

fftwtools’ mvfftw* functions transform each column. In zufft that is axes = 1.

m <- matrix(rnorm(24), 6)
all.equal(fft_c2c(m, axes = 1), fftwtools::mvfftw(m))
#> [1] TRUE
M <- fft_r2c(m, axes = 1)
all.equal(fft_c2r(M, n = 6, axes = 1, norm = "none"), fftwtools::mvfftw_c2r(M, HermConj = 0, n = 6))
#> [1] TRUE

Two, three and more dimensions

FFTW stores arrays row by row, so fftwtools’ real 2-D and 3-D transforms halve R’s first dimension. zufft’s real transforms do the same by default: in R the first dimension is the contiguous one, and halving it is the fast choice.

x2 <- matrix(rnorm(35), 5, 7)
all.equal(fft_r2c(x2), fftwtools::fftw_r2c_2d(x2, HermConj = 0))
#> [1] TRUE
all.equal(fft_c2c(x2), fftwtools::fftw2d(x2))
#> [1] TRUE

What you gain

• No system library. zufft compiles its bundled ducc0 code, so install.packages("zufft") is enough, everywhere.
• No GPL. zufft is MIT-licensed and its bundled code BSD-3, so a package that imports it keeps its own licence.
• Speed. On the benchmark grid in the package’s bench/RESULTS.md, zufft is faster than fftwtools on most cases and within 1.5 times everywhere, because it caches its plans while fftwtools plans on every call. Multi-dimensional complex transforms gain the most.
• Threads. workers = 2 (or fft_workers(2)) splits a transform over threads; fftwtools has none.
• More transforms. fft_dct() and fft_dst() (types 1 to 4), any subset of axes, cropping and zero-padding with n, and fft_next_len() for fast lengths.
• Untouched inputs. fft_c2r() never modifies its input, while FFTW’s complex-to-real transform destroys it.