FFTW 3.0.1

Node:Complex Multi-Dimensional DFTs, Next:One-Dimensional DFTs of Real Data, Previous:Complex One-Dimensional DFTs, Up:Tutorial

### 2.2 Complex Multi-Dimensional DFTs

Multi-dimensional transforms work much the same way as one-dimensional transforms: you allocate arrays of `fftw_complex` (preferably using `fftw_malloc`), create an `fftw_plan`, execute it as many times as you want with `fftw_execute(plan)`, and clean up with `fftw_destroy_plan(plan)` (and `fftw_free`). The only difference is the routine you use to create the plan:

    fftw_plan fftw_plan_dft_2d(int nx, int ny,
                               fftw_complex *in, fftw_complex *out,
                               int sign, unsigned flags);
    fftw_plan fftw_plan_dft_3d(int nx, int ny, int nz,
                               fftw_complex *in, fftw_complex *out,
                               int sign, unsigned flags);
    fftw_plan fftw_plan_dft(int rank, const int *n,
                            fftw_complex *in, fftw_complex *out,
                            int sign, unsigned flags);

These routines create plans for `nx` by `ny` two-dimensional (2d) transforms, `nx` by `ny` by `nz` 3d transforms, and arbitrary `rank`-dimensional transforms, respectively. In the third case, `n` is a pointer to an array `n[rank]` denoting an `n[0]` by `n[1]` by ... by `n[rank-1]` transform. All of these transforms operate on contiguous arrays in the C-standard row-major order, so that the last dimension has the fastest-varying index in the array. This layout is described further in Multi-dimensional Array Format.

You may have noticed that all the planner routines described so far have overlapping functionality. For example, you can plan a 1d or 2d transform by using `fftw_plan_dft` with a `rank` of `1` or `2`, or even by calling `fftw_plan_dft_3d` with `nx` and/or `ny` equal to `1` (with no loss in efficiency). This pattern continues, and FFTW's planning routines in general form a "partial order," sequences of interfaces with strictly increasing generality but correspondingly greater complexity.

`fftw_plan_dft` is the most general complex-DFT routine that we describe in this tutorial, but there are also the advanced and guru interfaces, which allow one to efficiently combine multiple/strided transforms into a single FFTW plan, transform a subset of a larger multi-dimensional array, and/or to handle more general complex-number formats. For more information, see FFTW Reference.