The default FFTW interface uses `double`

precision for all
floating-point numbers, and defines a `fftw_complex`

type to hold
complex numbers as:

typedef double fftw_complex[2];

Here, the `[0]`

element holds the real part and the `[1]`

element holds the imaginary part.

Alternatively, if you have a C compiler (such as `gcc`

) that
supports the C99 revision of the ANSI C standard, you can use C's new
native complex type (which is binary-compatible with the typedef above).
In particular, if you `#include <complex.h>`

*before*
`<fftw3.h>`

, then `fftw_complex`

is defined to be the native
complex type and you can manipulate it with ordinary arithmetic
(e.g. `x = y * (3+4*I)`

, where `x`

and `y`

are
`fftw_complex`

and `I`

is the standard symbol for the
imaginary unit);

C++ has its own `complex<T>`

template class, defined in the
standard `<complex>`

header file. Reportedly, the C++ standards
committee has recently agreed to mandate that the storage format used
for this type be binary-compatible with the C99 type, i.e. an array
`T[2]`

with consecutive real `[0]`

and imaginary `[1]`

parts. (See report
http://www.open-std.org/jtc1/sc22/WG21/docs/papers/2002/n1388.pdf WG21/N1388.) Although not part of the official standard as of this
writing, the proposal stated that: “This solution has been tested with
all current major implementations of the standard library and shown to
be working.” To the extent that this is true, if you have a variable
`complex<double> *x`

, you can pass it directly to FFTW via
`reinterpret_cast<fftw_complex*>(x)`

.