### 6.1 Fortran-interface routines

Nearly all of the FFTW functions have Fortran-callable equivalents. The name of the Fortran routine is the same as that of the corresponding C routine, but with the ``fftw_`' prefix replaced by ``dfftw_`'. (The single and long-double precision versions use ``sfftw_`' and ``lfftw_`', respectively, instead of ``fftwf_`' and ``fftwl_`'.)1

For the most part, all of the arguments to the functions are the same, with the following exceptions:

- `plan` variables (what would be of type `fftw_plan` in C), must be declared as a type that is at least as big as a pointer (address) on your machine. We recommend using `integer*8`.
- Any function that returns a value (e.g. `fftw_plan_dft`) is converted into a subroutine. The return value is converted into an additional first parameter of this subroutine.2
- The Fortran routines expect multi-dimensional arrays to be in column-major order, which is the ordinary format of Fortran arrays (see Multi-dimensional Array Format). They do this transparently and costlessly simply by reversing the order of the dimensions passed to FFTW, but this has one important consequence for multi-dimensional real-complex transforms, discussed below.
- Wisdom import and export is somewhat more tricky because one cannot easily pass files or strings between C and Fortran; see Wisdom of Fortran?.
- Fortran cannot use the `fftw_malloc` dynamic-allocation routine. If you want to exploit the SIMD FFTW (see Data Alignment), you'll need to figure out some other way to ensure that your arrays are at least 16-byte aligned.
- Since Fortran 77 does not have data structures, the `fftw_iodim` structure from the guru interface (see Guru vector and transform sizes) must be split into separate arguments. In particular, any `fftw_iodim` array arguments in the C guru interface become three integer array arguments (`n`, `is`, and `os`) in the Fortran guru interface, all of whose lengths should be equal to the corresponding `rank` argument.

In general, you should take care to use Fortran data types that correspond to (i.e. are the same size as) the C types used by FFTW. If your C and Fortran compilers are made by the same vendor, the correspondence is usually straightforward (i.e. `integer` corresponds to `int`, `real` corresponds to `float`, etcetera). The native Fortran double/single-precision complex type should be compatible with `fftw_complex`/`fftwf_complex`. Such simple correspondences are assumed in the examples below.

#### Footnotes

[1] Technically, Fortran 77 identifiers are not allowed to have more than 6 characters, nor may they contain underscores. Any compiler that enforces this limitation doesn't deserve to link to FFTW.

[2] The reason for this is that some Fortran implementations seem to have trouble with C function return values, and vice versa.