Is FFTW significantly better than GSL for real transform calculations?

Question

I'm unable to get FFTW to link to my code in order to use its functions in my code. I have spent enough time on this that I am considering giving up on it.

I am very familiar with GSL, and have used the linear algebra libraries extensively with good results. GSL also has a set of FFT functions that seem to do the same things as FFTW. Are they just as good? Or is FFTW significantly better, and worth spending more time to try to get it to work?

(By the way, my error is that using g++ on a remote system on which I am not the admin, I am unable to compile my code to recognize references to FFTW calls. My makefile includes -L/libdirectory -lfftw3 but I still get undefined references for some (not all) fftw functions).

Here is the source:
#include "fftw3.h"
in = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * length);

Here is the relevant compile command:
g++ -std=c++0x -fPIC ... -lm ... -L/libdirectory -lfftw3

Here is the error:
/source.cc: undefined reference to 'fftw_malloc'

Note that the compiler is able to find fftw3.h. I also can declare objects such as fftw_complex and fftw_plan.

EDIT: I still can't get my Makefile to link the static library. However, I was able to recompile with shared libraries and those seem to have worked so far. I still would like to see some benchmarks newer than 11 years old, though!

Answer 1

You didn't mention what you would consider "significantly better" which could means a variety of things from speed, accuracy, ease of use, maintenance, licensing, etc. But I assume you are primarily interested in speed and accuracy comparisons.

For the speed aspect, the reference section of GNU GSL documentation mentions:

For large-scale FFT work we recommend the use of the dedicated FFTW library by Frigo and Johnson. The FFTW library is self-optimizing—it automatically tunes itself for each hardware platform in order to achieve maximum performance.

So according to GSL developers' own admission, FFTW is expected to outperform GSL. How much so? You can have a look at this speed performance benchmark from FFTW which suggests that GSL is about 3-4 times slower than FFTW 3. Note that this benchmark hasn't been done with g++ (and there doesn't seem to be another readily available benchmark for the gcc compilers from FFTW's site which includes GSL), and quite likely on a machine with different than yours, so your own results may vary. On the accuracy front this accuracy benchmark from FFTW suggests that they have similar accuracy for most case (with FFTW being slightly more accurate) but that GSL tend to exhibit accuracy degradation for real data and larger transform sizes.

For sake of completeness I'll briefly mention that as far as licensing goes, they both offer GNU GPL license, but FFTW also offers a non-free license, which could be considered better by someone for which the GNU GPL license is problematic. Otherwise for ease-of-use and maintenance, they are both actively developed and offer different but similarly complex APIs. So for those aspects, preference of one library over the other may be based on factors other that the FFT's implementation merits.