GNU Info

(fftw.info)rfftwnd_create_plan

---

Next: rfftwnd Prev: Real Multi-dimensional Transforms Reference Up: Real Multi-dimensional Transforms Reference

---

Enter node , (file) or (file)node

Plan Creation for Real Multi-dimensional Transforms
---------------------------------------------------

     #include <rfftw.h>
     
     rfftwnd_plan rfftwnd_create_plan(int rank, const int *n,
                                      fftw_direction dir, int flags);
     
     rfftwnd_plan rfftw2d_create_plan(int nx, int ny,
                                      fftw_direction dir, int flags);
     
     rfftwnd_plan rfftw3d_create_plan(int nx, int ny, int nz,
                                      fftw_direction dir, int flags);

   The function `rfftwnd_create_plan' creates a plan, which is a data
structure containing all the information that `rfftwnd' needs in order
to compute a multi-dimensional real Fourier transform.  You can create
as many plans as you need, but only one plan for a given array size is
required (a plan can be reused many times).  The functions
`rfftw2d_create_plan' and `rfftw3d_create_plan' are optional,
alternative interfaces to `rfftwnd_create_plan' for two and three
dimensions, respectively.

   `rfftwnd_create_plan' returns a valid plan, or `NULL' if, for some
reason, the plan can't be created.  This can happen if the arguments
are invalid in some way (e.g. if `rank' < 0).

Arguments
.........

   * `rank' is the dimensionality of the arrays to be transformed.  It
     can be any non-negative integer.

   * `n' is a pointer to an array of `rank' integers, giving the size
     of each dimension of the arrays to be transformed.  Note that these
     are always the dimensions of the *real* arrays; the complex arrays
     have different dimensions (Note: Array Dimensions for Real
     Multi-dimensional Transforms.).  These sizes, which must be
     positive integers, correspond to the dimensions of row-major
     arrays--i.e. `n[0]' is the size of the dimension whose indices
     vary most slowly, and so on. (Note: Multi-dimensional Array
     Format, for more information.)
        - *Note Plan Creation for Real One-dimensional Transforms:
          rfftw_create_plan, for more information regarding optimal
          array sizes.

   * `nx' and `ny' in `rfftw2d_create_plan' are positive integers
     specifying the dimensions of the rank 2 array to be transformed.
     i.e. they specify that the transform will operate on `nx x ny'
     arrays in row-major order, where `nx' is the number of rows and
     `ny' is the number of columns.

   * `nx', `ny' and `nz' in `rfftw3d_create_plan' are positive integers
     specifying the dimensions of the rank 3 array to be transformed.
     i.e. they specify that the transform will operate on `nx x ny x
     nz' arrays in row-major order.

   * `dir' is the direction of the desired transform, either
     `FFTW_REAL_TO_COMPLEX' or `FFTW_COMPLEX_TO_REAL', corresponding to
     `FFTW_FORWARD' or `FFTW_BACKWARD', respectively.

   * `flags' is a boolean OR (`|') of zero or more of the following:
        - `FFTW_MEASURE': this flag tells FFTW to find the optimal plan
          by actually *computing* several FFTs and measuring their
          execution time.

        - `FFTW_ESTIMATE': do not run any FFT and provide a "reasonable"
          plan (for a RISC processor with many registers).  If neither
          `FFTW_ESTIMATE' nor `FFTW_MEASURE' is provided, the default is
          `FFTW_ESTIMATE'.

        - `FFTW_OUT_OF_PLACE': produce a plan assuming that the input
          and output arrays will be distinct (this is the default).

        - `FFTW_IN_PLACE': produce a plan assuming that you want to
          perform the transform in-place.  (Unlike the one-dimensional
          transform, this "really" performs the transform in-place.)
          Note that, if you want to perform in-place transforms, you
          *must* use a plan created with this option.  The use of this
          option has important implications for the size of the
          input/output array (Note: Computing the Real
          Multi-dimensional Transform.).

          The default mode of operation is `FFTW_OUT_OF_PLACE'.

        - `FFTW_USE_WISDOM': use any `wisdom' that is available to help
          in the creation of the plan. (Note: Words of Wisdom.)  This
          can greatly speed the creation of plans, especially with the
          `FFTW_MEASURE' option. `FFTW_ESTIMATE' plans can also take
          advantage of `wisdom' to produce a more optimal plan (based
          on past measurements) than the estimation heuristic would
          normally generate. When the `FFTW_MEASURE' option is used,
          new `wisdom' will also be generated if the current transform
          size is not completely understood by existing `wisdom'. Note
          that the same `wisdom' is shared between one-dimensional and
          multi-dimensional transforms.