d@0: d@0: d@0: Next: Real-data DFT Array Format, d@0: Previous: Planner Flags, d@0: Up: Basic Interface d@0:
fftw_plan fftw_plan_dft_r2c_1d(int n, d@0: double *in, fftw_complex *out, d@0: unsigned flags); d@0: fftw_plan fftw_plan_dft_r2c_2d(int n0, int n1, d@0: double *in, fftw_complex *out, d@0: unsigned flags); d@0: fftw_plan fftw_plan_dft_r2c_3d(int n0, int n1, int n2, d@0: double *in, fftw_complex *out, d@0: unsigned flags); d@0: fftw_plan fftw_plan_dft_r2c(int rank, const int *n, d@0: double *in, fftw_complex *out, d@0: unsigned flags); d@0:d@0:
d@0: Plan a real-input/complex-output discrete Fourier transform (DFT) in
d@0: zero or more dimensions, returning an fftw_plan (see Using Plans).
d@0:
d@0:
Once you have created a plan for a certain transform type and d@0: parameters, then creating another plan of the same type and parameters, d@0: but for different arrays, is fast and shares constant data with the d@0: first plan (if it still exists). d@0: d@0:
The planner returns NULL if the plan cannot be created. A
d@0: non-NULL plan is always returned by the basic interface unless
d@0: you are using a customized FFTW configuration supporting a restricted
d@0: set of transforms, or if you use the FFTW_PRESERVE_INPUT flag
d@0: with a multi-dimensional out-of-place c2r transform (see below).
d@0:
d@0:
rank is the dimensionality of the transform (it should be the
d@0: size of the array *n), and can be any non-negative integer. The
d@0: `_1d', `_2d', and `_3d' planners correspond to a
d@0: rank of 1, 2, and 3, respectively. A
d@0: rank of zero is equivalent to a transform of size 1, i.e. a copy
d@0: of one number (with zero imaginary part) from input to output.
d@0:
d@0: n, or n0/n1/n2, or n[rank],
d@0: respectively, gives the size of the logical transform dimensions.
d@0: They can be any positive integer. This is different in general from the
d@0: physical array dimensions, which are described in Real-data DFT Array Format.
d@0:
d@0: performance even for prime sizes). (It is possible to customize FFTW d@0: for different array sizes; see Installation and Customization.) d@0: Transforms whose sizes are powers of 2 are especially fast, and d@0: it is generally beneficial for the last dimension of an r2c/c2r d@0: transform to be even. d@0:
in and out point to the input and output arrays of the
d@0: transform, which may be the same (yielding an in-place transform).
d@0: These arrays are overwritten during planning, unless
d@0: FFTW_ESTIMATE is used in the flags. (The arrays need not be
d@0: initialized, but they must be allocated.) For an in-place transform, it
d@0: is important to remember that the real array will require padding,
d@0: described in Real-data DFT Array Format.
d@0:
d@0: flags is a bitwise OR (`|') of zero or more planner flags,
d@0: as defined in Planner Flags.
d@0:
d@0: The inverse transforms, taking complex input (storing the non-redundant d@0: half of a logically Hermitian array) to real output, are given by: d@0: d@0:
fftw_plan fftw_plan_dft_c2r_1d(int n, d@0: fftw_complex *in, double *out, d@0: unsigned flags); d@0: fftw_plan fftw_plan_dft_c2r_2d(int n0, int n1, d@0: fftw_complex *in, double *out, d@0: unsigned flags); d@0: fftw_plan fftw_plan_dft_c2r_3d(int n0, int n1, int n2, d@0: fftw_complex *in, double *out, d@0: unsigned flags); d@0: fftw_plan fftw_plan_dft_c2r(int rank, const int *n, d@0: fftw_complex *in, double *out, d@0: unsigned flags); d@0:d@0:
d@0: The arguments are the same as for the r2c transforms, except that the d@0: input and output data formats are reversed. d@0: d@0:
FFTW computes an unnormalized transform: computing an r2c followed by a
d@0: c2r transform (or vice versa) will result in the original data
d@0: multiplied by the size of the transform (the product of the logical
d@0: dimensions).
d@0: An r2c transform produces the same output as a FFTW_FORWARD
d@0: complex DFT of the same input, and a c2r transform is correspondingly
d@0: equivalent to FFTW_BACKWARD. For more information, see What FFTW Really Computes.
d@0:
d@0:
d@0:
d@0: