FFTW

https://www.fftw.org/
Admin
FFTW is a C subroutine library for computing the discrete Fourier transform (DFT) in one or more...
Tokens:75,894
Snippets:929
Trust Score:9.8
Update:2 months ago
Show doc for...
Tokens:
Raw
### Standard FFTW Installation

Source: https://www.fftw.org/doc/Installation-on-Unix.html

The basic sequence of commands to configure, build, and install the FFTW library.

```bash
./configure
make
make install
```

--------------------------------

### Test Library Installation

Source: https://www.fftw.org/install/fftw-3.0.1BC_installation.txt

Commands to verify the library installation using the provided Perl script or the bench utility.

```bash
perl check.pl --random
```

```bash
bench -y irf256x256
```

--------------------------------

### Examples of transform size specifications

Source: https://www.fftw.org/fftw-wisdom.1.html

Syntax examples for defining transform types, directions, and geometries.

```text
cif12x13x14
```

```text
rob65536
```

```text
ki10hx20e01
```

--------------------------------

### Rename File Example

Source: https://www.fftw.org/install/fftw-3.0.1BC_installation.txt

Shows the naming convention used for source files by prefixing the parent directory.

```text
reodft\conf.c  becomes reodft\reodft_conf.c
```

--------------------------------

### Configure and build FFTW with MinGW

Source: https://www.fftw.org/install/windows.html

Example configuration command for building a double-precision library under MinGW, followed by standard make commands.

```bash
    ./configure --with-our-malloc16 --with-windows-f77-mangling --enable-shared --disable-static --enable-threads --with-combined-threads --enable-portable-binary --enable-sse2 --with-incoming-stack-boundary=2
    make
    make install

```

--------------------------------

### Generate FFTW Configuration Routine

Source: https://www.fftw.org/fftw-wisdom-to-conf.1.html

Example commands to generate wisdom for specific transforms and convert that wisdom into a C configuration file.

```bash
fftw-wisdom -n cof1024 cob1024 -o wisdom   
fftw-wisdom-to-conf < wisdom > conf.c
```

--------------------------------

### FFTW Example Implementation in Delphi

Source: https://www.fftw.org/install/fftw_usage_from_delphi.txt

Demonstrates how to declare variables and invoke FFTW plan creation within a Delphi console application.

```pascal
program fftw_example;
    
    uses
      SysUtils,
      fftw_interface in 'fftw_interface.pas';
    
    var
      in, out : Array of Single;
      plan : Pointer;
    
    {$APPTYPE CONSOLE}
    
    begin

      ...  

      SetLength(in, N);
      SetLength(out, N);
    
      plan := _fftwf_plan_dft_1d(dataLength, @in[0], @out[0],
                                 FFTW_FORWARD, FFTW_ESTIMATE);
      ...
```

--------------------------------

### Initialize multi-threaded FFTW in Fortran

Source: https://www.fftw.org/doc/Fortran-Examples.html

Setup for parallel execution using 8 threads.

```fortran
        integer iret
        call dfftw_init_threads(iret)
        call dfftw_plan_with_nthreads(8)
```

--------------------------------

### Configure and Install FFTW for Cell

Source: https://www.fftw.org/cell

Commands to build and install FFTW with Cell processor support enabled for double or single precision.

```bash
   configure --enable-cell
   make
   make install
```

```bash
   configure --enable-cell --enable-single
   make
   make install
```

--------------------------------

### Configure FFTW for ARM with NEON support

Source: https://www.fftw.org/doc/Installation-on-Unix.html

Example command for configuring FFTW on an ARM architecture, specifying the cross-compiler and necessary flags for NEON support.

```bash
./configure --with-slow-timer --host=arm-linux-gnueabi \
  --enable-single --enable-neon \
  "CC=arm-linux-gnueabi-gcc -march=armv7-a -mfloat-abi=softfp"
```

--------------------------------

### Example parallel loop callback

Source: https://www.fftw.org/doc/Usage-of-Multi_002dthreaded-FFTW.html

A sample implementation of a parallel loop using OpenMP for the custom threading callback interface.

```c
void parallel_loop(void *(*work)(char *), char *jobdata, size_t elsize, int njobs, void *data)
{
#pragma omp parallel for
    for (int i = 0; i < njobs; ++i)
        work(jobdata + elsize * i);
}
```

--------------------------------

### Perform a distributed 2D complex DFT in-place

Source: https://www.fftw.org/doc/FFTW-MPI-Fortran-Interface.html

Example demonstrating the initialization, allocation, planning, and execution of a 2D complex DFT using the FFTW MPI Fortran interface.

```Fortran
  use, intrinsic :: iso_c_binding
  include 'fftw3-mpi.f03'
  integer(C_INTPTR_T), parameter :: L = ...
  integer(C_INTPTR_T), parameter :: M = ...
  type(C_PTR) :: plan, cdata
  complex(C_DOUBLE_COMPLEX), pointer :: data(:,:)
  integer(C_INTPTR_T) :: i, j, alloc_local, local_M, local_j_offset

!   get local data size and allocate (note dimension reversal)
  alloc_local = fftw_mpi_local_size_2d(M, L, MPI_COMM_WORLD, &
                                       local_M, local_j_offset)
  cdata = fftw_alloc_complex(alloc_local)
  call c_f_pointer(cdata, data, [L,local_M])

!   create MPI plan for in-place forward DFT (note dimension reversal)
  plan = fftw_mpi_plan_dft_2d(M, L, data, data, MPI_COMM_WORLD, &
                              FFTW_FORWARD, FFTW_MEASURE)

! initialize data to some function my_function(i,j)
  do j = 1, local_M
    do i = 1, L
      data(i, j) = my_function(i, j + local_j_offset)
    end do
  end do

! compute transform (as many times as desired)
  call fftw_mpi_execute_dft(plan, data, data)

  call fftw_destroy_plan(plan)
  call fftw_free(cdata)
```

--------------------------------

### Perform a 2D r2r transform with MPI

Source: https://www.fftw.org/doc/Other-Multi_002ddimensional-Real_002ddata-MPI-Transforms.html

Example of a 2D REDFT10 by RODFT10 transform using MPI, demonstrating local size allocation and plan creation.

```c
    const ptrdiff_t L = ..., M = ...;
    fftw_plan plan;
    double *data;
    ptrdiff_t alloc_local, local_n0, local_0_start, i, j;

    /* get local data size and allocate */
    alloc_local = fftw_mpi_local_size_2d(L, M, MPI_COMM_WORLD,
                                         &local_n0, &local_0_start);
    data = fftw_alloc_real(alloc_local);

    /* create plan for in-place REDFT10 x RODFT10 */
    plan = fftw_mpi_plan_r2r_2d(L, M, data, data, MPI_COMM_WORLD,
                                FFTW_REDFT10, FFTW_RODFT10, FFTW_MEASURE);

    /* initialize data to some function my_function(x,y) */
    for (i = 0; i < local_n0; ++i) for (j = 0; j < M; ++j)
       data[i*M + j] = my_function(local_0_start + i, j);

    /* compute transforms, in-place, as many times as desired */
    fftw_execute(plan);

    fftw_destroy_plan(plan);
```

--------------------------------

### Define 3D Array Dimensions

Source: https://www.fftw.org/doc/Reversing-array-dimensions.html

Example of declaring a 3D complex array in Fortran.

```Fortran
  complex(C_DOUBLE_COMPLEX), dimension(L,M,N) :: in, out
```

--------------------------------

### MPI_Alltoall call for double arrays

Source: https://www.fftw.org/doc/An-improved-replacement-for-MPI_005fAlltoall.html

Example usage of MPI_Alltoall for double-precision floating-point arrays.

```c
MPI_Alltoall(in, howmany, MPI_DOUBLE, out, howmany MPI_DOUBLE, comm);
```

--------------------------------

### Planning a 3D DFT with a fixed-size array

Source: https://www.fftw.org/doc/Fixed_002dsize-Arrays-in-C.html

Demonstrates passing a pointer to the first element of a statically sized 3D array to the FFTW planner.

```c
{
     fftw_complex data[N0][N1][N2];
     fftw_plan plan;
     ...
     plan = fftw_plan_dft_3d(N0, N1, N2, &data[0][0][0], &data[0][0][0],
                             FFTW_FORWARD, FFTW_ESTIMATE);
     ...
}
```

--------------------------------

### Create Visual C++ import libraries

Source: https://www.fftw.org/install/windows.html

Use the lib.exe tool to generate .lib import libraries from the provided .def files for Visual C++.

```bash
     lib /def:libfftw3-3.def
     lib /def:libfftw3f-3.def
     lib /def:libfftw3l-3.def
```

--------------------------------

### Real-to-Complex 3D Transform

Source: https://www.fftw.org/doc/Reversing-array-dimensions.html

Example of an r2c transform where the first dimension of the complex output is halved.

```Fortran
  type(C_PTR) :: plan
  real(C_DOUBLE), dimension(L,M,N) :: in
  complex(C_DOUBLE_COMPLEX), dimension(L/2+1,M,N) :: out
  plan = fftw_plan_dft_r2c_3d(N,M,L, in,out, FFTW_ESTIMATE)
  ...
  call fftw_execute_dft_r2c(plan, in, out)
```

--------------------------------

### Import FFTW Wisdom from File

Source: https://www.fftw.org/doc/Words-of-Wisdom_002dSaving-Plans.html

Restores wisdom from a file to enable plan reconstruction.

```c
int fftw_import_wisdom_from_filename(const char *filename);
```

--------------------------------

### Build Library Commands

Source: https://www.fftw.org/install/fftw-3.0.1BC_installation.txt

Commands to initiate the build process for the main library and the threads library.

```bash
make
```

```bash
cd into the "threads\" directory and type "make".
```

--------------------------------

### Get Plan Floating-Point Operations

Source: https://www.fftw.org/doc/Using-Plans.html

Calculates the exact count of additions, multiplications, and fused multiply-add operations for a plan.

```c
void fftw_flops(const fftw_plan plan,
                double *add, double *mul, double *fma);
```

--------------------------------

### Get Plan Cost

Source: https://www.fftw.org/doc/Using-Plans.html

Returns the internal cost metric of a plan, which is proportional to execution time for measured plans.

```c
double fftw_cost(const fftw_plan plan);
```

--------------------------------

### Execute FFTW plan in Fortran

Source: https://www.fftw.org/doc/Overview-of-Fortran-interface.html

Demonstrates declaring a plan, defining arrays, creating a plan, executing it, and destroying it.

```fortran
  type(C_PTR) :: plan
  complex(C_DOUBLE_COMPLEX), dimension(1024,1000) :: in, out
  plan = fftw_plan_dft_2d(1000,1024, in,out, FFTW_FORWARD,FFTW_ESTIMATE)
  ...
  call fftw_execute_dft(plan, in, out)
  ...
  call fftw_destroy_plan(plan)
```

--------------------------------

### Planning Backward Transform with Split Arrays

Source: https://www.fftw.org/doc/Guru-Complex-DFTs.html

Demonstrates how to compute an FFTW_BACKWARD transform using the split DFT planner by swapping real and imaginary pointers.

```c
ri = (double *) in + 1;
ii = (double *) in;
ro = (double *) out + 1;
io = (double *) out;
```

--------------------------------

### Create 64-bit Visual C++ import library

Source: https://www.fftw.org/install/windows.html

Specify the machine architecture explicitly when creating import libraries for 64-bit Visual Studio environments.

```bash
     lib /machine:x64 /def:libfftw3l-3.def
```

--------------------------------

### Configure Fortran Attributes for Digital Visual Fortran

Source: https://www.fftw.org/install/windows.html

Include this directive at the start of a Fortran program to enable calling FFTW routines like fftw_f77.

```fortran
!DEC$ ATTRIBUTES C, REFERENCE :: fftw_f77
```

--------------------------------

### Mapping fftw_complex to Split Array Parameters

Source: https://www.fftw.org/doc/Guru-Complex-DFTs.html

Example showing how to map interleaved fftw_complex pointers to the real and imaginary components required by the split DFT planner.

```c
ri = (double *) in;
ii = (double *) in + 1;
ro = (double *) out;
io = (double *) out + 1;
```

--------------------------------

### Initialize FFTW Fortran interface

Source: https://www.fftw.org/doc/Overview-of-Fortran-interface.html

Include the necessary module and interface file at the beginning of any Fortran subroutine using FFTW.

```fortran
  use, intrinsic :: iso_c_binding 
  include 'fftw3.f03'
```

--------------------------------

### Basic 1D DFT Workflow

Source: https://www.fftw.org/doc/Complex-One_002dDimensional-DFTs.html

Standard sequence for allocating memory, creating a plan, executing the transform, and cleaning up resources.

```c
#include <fftw3.h>
...
{
    fftw_complex *in, *out;
    fftw_plan p;
    ...
    in = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * N);
    out = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * N);
    p = fftw_plan_dft_1d(N, in, out, FFTW_FORWARD, FFTW_ESTIMATE);
    ...
    fftw_execute(p); /* repeat as needed */
    ...
    fftw_destroy_plan(p);
    fftw_free(in); fftw_free(out);
}
```

--------------------------------

### Define function alias for Borland C++

Source: https://www.fftw.org/install/bcb-fftw3.html

Example of an alias entry in a .def file to map Borland's expected leading underscore function name to the exported DLL symbol.

```text
    _fftw_version                  = fftw_version
```

--------------------------------

### Enable thread-safe planning in FFTW

Source: https://www.fftw.org/doc/Thread-safety.html

Installs a global lock around all planner calls to allow thread-safe planning in environments where coordination is impossible. This should be used only as a last resort due to performance and flexibility limitations.

```c
void fftw_make_planner_thread_safe(void);
```

--------------------------------

### Import wisdom from a file in MPI

Source: https://www.fftw.org/doc/FFTW-MPI-Wisdom.html

Imports wisdom on process 0 and broadcasts it to all other processes in the communicator.

```c
{
    int rank;

    fftw_mpi_init();
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    if (rank == 0) fftw_import_wisdom_from_filename("mywisdom");
    fftw_mpi_broadcast_wisdom(MPI_COMM_WORLD);
}
```

--------------------------------

### Create 2D and 3D DFT plans

Source: https://www.fftw.org/doc/Complex-Multi_002dDimensional-DFTs.html

Signatures for creating plans for fixed-dimension 2D and 3D complex transforms.

```c
fftw_plan fftw_plan_dft_2d(int n0, int n1,
                           fftw_complex *in, fftw_complex *out,
                           int sign, unsigned flags);
fftw_plan fftw_plan_dft_3d(int n0, int n1, int n2,
                           fftw_complex *in, fftw_complex *out,
                           int sign, unsigned flags);
```

--------------------------------

### Fortran Interface Conventions

Source: https://www.fftw.org/doc/Fortran_002dinterface-routines.html

Overview of how to map FFTW C functions to their Fortran equivalents, including naming conventions and argument handling.

```APIDOC
## Fortran Interface Conventions

### Naming Convention
- Double precision: `dfftw_` prefix
- Single precision: `sfftw_` prefix
- Long-double precision: `lfftw_` prefix
- Quadruple precision: `fftwq_` prefix

### Argument Mapping
- `plan` variables: Use `integer*8` to ensure sufficient size for pointers.
- Return values: Functions returning values in C are converted to subroutines in Fortran, with the return value added as the first parameter.
- Multi-dimensional arrays: Fortran uses column-major order; FFTW handles this by reversing dimension order.
- Guru interface: `fftw_iodim` structures are split into three separate integer arrays (`n`, `is`, `os`) of length `rank`.
```

--------------------------------

### Plan 3D DFT with Generic Routine

Source: https://www.fftw.org/doc/Reversing-array-dimensions.html

Using the generic fftw_plan_dft_3d routine with an integer array for dimensions.

```Fortran
  integer(C_INT), dimension(3) :: n = [N,M,L]
  plan = fftw_plan_dft_3d(3, n, in,out, FFTW_FORWARD,FFTW_ESTIMATE)
```

--------------------------------

### Configure FFTW with MPI support

Source: https://www.fftw.org/doc/FFTW-MPI-Installation.html

Basic command to enable MPI during the FFTW configuration process.

```bash
./configure --enable-mpi
```

--------------------------------

### 64-bit Guru DFT Planner Routine

Source: https://www.fftw.org/doc/64_002dbit-Guru-Interface.html

The signature for the 64-bit guru DFT planner, which uses fftw_iodim64 for dimension specifications.

```c
fftw_plan fftw_plan_guru64_dft(
     int rank, const fftw_iodim64 *dims,
     int howmany_rank, const fftw_iodim64 *howmany_dims,
     fftw_complex *in, fftw_complex *out,
     int sign, unsigned flags);
```

--------------------------------

### Perform 3D in-place DFT in C and Fortran

Source: https://www.fftw.org/doc/Fortran-Examples.html

Comparison of 3D in-place array transformation between C and Fortran.

```c
        fftw_complex arr[L][M][N];
        fftw_plan plan;

        plan = fftw_plan_dft_3d(L,M,N, arr,arr,
                                FFTW_FORWARD, FFTW_ESTIMATE);
        fftw_execute(plan);
        fftw_destroy_plan(plan);
```

```fortran
        double complex arr
        dimension arr(L,M,N)
        integer*8 plan

        call dfftw_plan_dft_3d(plan, L,M,N, arr,arr,
       &                       FFTW_FORWARD, FFTW_ESTIMATE)
        call dfftw_execute_dft(plan, arr, arr)
        call dfftw_destroy_plan(plan)
```

--------------------------------

### Configure tests/Makefile for Alpha Digital Unix

Source: https://www.fftw.org/install/alpha.html

Compiler flags for the tests directory, including XOPEN source extensions.

```makefile
# Alpha under Digital Unix
CC = cc
CFLAGS = -newc -w0 -O4 -ansi_alias -ansi_args -fp_reorder -tune host \
         -std1 $(INCLUDE) -D_XOPEN_SOURCE_EXTENDED
```

--------------------------------

### Configure Precision Settings in config.h

Source: https://www.fftw.org/install/fftw-3.0.1BC_installation.txt

Toggle these defines to switch between single and double precision floating point arithmetic.

```c
#define BENCHFFT_SINGLE 1

#define FFTW_SINGLE 1
```

```c
#undef BENCHFFT_SINGLE

#undef FFTW_SINGLE
```

--------------------------------

### Initialize MPI and FFTW threads

Source: https://www.fftw.org/doc/Combining-MPI-and-Threads.html

Use MPI_Init_thread with MPI_THREAD_FUNNELED to ensure thread safety, and initialize FFTW threads before MPI.

```c
int threads_ok;

int main(int argc, char **argv)
{
    int provided;
    MPI_Init_thread(&argc, &argv, MPI_THREAD_FUNNELED, &provided);
    threads_ok = provided >= MPI_THREAD_FUNNELED;

    if (threads_ok) threads_ok = fftw_init_threads();
    fftw_mpi_init();

    ...
    if (threads_ok) fftw_plan_with_nthreads(...);
    ...
    
    MPI_Finalize();
}
```

--------------------------------

### MMS Configuration for VMS

Source: https://www.fftw.org/install/vms.html

Configuration file for building FFTW libraries and test programs on VMS using the MMS build tool.

```makefile
FFTWDIR=[-.src]
LIBFFT = $(FFTWDIR)libfftw.olb
HEADERS = $(FFTWDIR)fftw.h
INCLUDE = /include=$(FFTWDIR)

# DECC
CC = cc
CFLAGS = /optimize$(INCLUDE)

all :
        mms fftw_test
        mms testnd

fftw_test :fftw_test.c $(LIBFFT)
        $(CC) $(CFLAGS) fftw_test.c
        $(CC) $(CFLAGS) getopt.c
        link fftw_test,getopt,$(LIBFFT)/l

testnd :testnd.c go_fft.c $(LIBFFT)
        $(CC) $(CFLAGS) testnd.c
        $(CC) $(CFLAGS) go_fft.c
        link testnd,go_fft,$(LIBFFT)/l

clean :
        rm -f *.o *~ core a.out test testnd gmon.out mon.out *.s
```

--------------------------------

### fftw_plan fftw_copy_plan(fftw_plan plan)

Source: https://www.fftw.org/doc/Using-Plans.html

Creates a copy of an fftw_plan instance.

```APIDOC
## fftw_plan fftw_copy_plan(fftw_plan plan)

### Description
Creates a copy of an fftw_plan instance. The plan is not deallocated until fftw_destroy_plan is called on both the original and the copy.

### Parameters
- **plan** (fftw_plan) - The plan to copy.
```

--------------------------------

### Export and Import Wisdom via Filename in Fortran

Source: https://www.fftw.org/doc/Wisdom-File-Export_002fImport-from-Fortran.html

Uses fftw_export_wisdom_to_filename and fftw_import_wisdom_from_filename. Requires null-terminated C strings using C_CHAR and C_NULL_CHAR.

```fortran
  integer(C_INT) :: ret
  ret = fftw_export_wisdom_to_filename(C_CHAR_'my_wisdom.dat' // C_NULL_CHAR)
  if (ret .eq. 0) stop 'error exporting wisdom to file'
  ret = fftw_import_wisdom_from_filename(C_CHAR_'my_wisdom.dat' // C_NULL_CHAR)
  if (ret .eq. 0) stop 'error importing wisdom from file'
```

--------------------------------

### Create Borland C++ import libraries

Source: https://www.fftw.org/install/windows.html

Use the implib utility to generate import libraries compatible with Borland C++ compilers.

```bash
     implib -a fftw3-3.lib libfftw3-3.dll
     implib -a fftw3f-3.lib libfftw3f-3.dll
     implib -a fftw3l-3.lib libfftw3l-3.dll
```

--------------------------------

### Multi-Dimensional Real-to-Complex Planner Routines

Source: https://www.fftw.org/doc/Multi_002dDimensional-DFTs-of-Real-Data.html

Planner functions for 2D, 3D, and general N-dimensional real-to-complex DFTs.

```c
fftw_plan fftw_plan_dft_r2c_2d(int n0, int n1,
                               double *in, fftw_complex *out,
                               unsigned flags);
fftw_plan fftw_plan_dft_r2c_3d(int n0, int n1, int n2,
                               double *in, fftw_complex *out,
                               unsigned flags);
fftw_plan fftw_plan_dft_r2c(int rank, const int *n,
                            double *in, fftw_complex *out,
                            unsigned flags);
```

--------------------------------

### Print Plan Representation

Source: https://www.fftw.org/doc/Using-Plans.html

Outputs a human-readable representation of the plan to a file, stdout, or a string.

```c
void fftw_fprint_plan(const fftw_plan plan, FILE *output_file);
void fftw_print_plan(const fftw_plan plan);
char *fftw_sprint_plan(const fftw_plan plan);
```

--------------------------------

### Equivalence of 2D and arbitrary rank planning

Source: https://www.fftw.org/doc/Complex-Multi_002dDimensional-DFTs.html

Demonstrates how a 2D transform call is equivalent to using the general arbitrary rank planning function.

```c
fftw_plan_dft_2d(n0, n1, in, out, sign, flags);
```

```c
int n[2];
n[0] = n0;
n[1] = n1;
fftw_plan_dft(2, n, in, out, sign, flags);
```
Tokens:
Raw