kml_fft(f/h)_plan_guru_split_dft

Create a plan for the n-dimensional C2C transform of multiple data sequences. The data sequence of a single FFT does not need to be contiguous and can be strided. The input and output of the split interfaces are stored in the real and imaginary arrays, respectively.

Interface Definition

C interface:

kml_fft_plan kml_fft_plan_guru_split_dft(int rank, const kml_fft_iodim *dims, int howmany_rank, const kml_fft_iodim *howmany_dims, double *ri, double *ii, double *ro, double *io, unsigned flags);

kml_fftf_plan kml_fftf_plan_guru_split_dft(int rank, const kml_fftf_iodim *dims, int howmany_rank, const kml_fftf_iodim *howmany_dims, float *ri, float *ii, float *ro, float *io, unsigned flags);

kml_ffth_plan kml_ffth_plan_guru_split_dft(int rank, const kml_ffth_iodim *dims, int howmany_rank, const kml_ffth_iodim *howmany_dims, __fp16 *ri, __fp16*ii, __fp16 *ro, __fp16 *io, unsigned flags);

Fortran interface:

RES = KML_FFT_PLAN_GURU_SPLIT_DFT(RANK, DIMS, HOWMANY_RANK, HOWMANY_DIMS, RI, II, RO, IO, FLAGS);

RES = KML_FFTF_PLAN_GURU_SPLIT_DFT(RANK, DIMS, HOWMANY_RANK, HOWMANY_DIMS, RI, II, RO, IO, FLAGS);

RES = KML_FFTH_PLAN_GURU_SPLIT_DFT(RANK, DIMS, HOWMANY_RANK, HOWMANY_DIMS, RI, II, RO, IO, FLAGS);

Return Value

The function returns a structure pointer of the kml_fft(f/h)_plan type. This object can be passed to the kml_fft(f/h)_execute function as a parameter to perform FFT on the inputs ri and ii and outputs ro and io. It can also be passed to the kml_fft(f/h)_execute_split_dft function as a parameter to perform FFT on new inputs ri and ii and outputs ro and io.

If this function returns a non-null pointer, the plan has been successfully created. Otherwise, the plan fails to be created.

Parameters

Parameter	Data Type	Description	Input/Output
rank	int	Dimension of a single FFT sequence. Constraint: 1 ≤ rank ≤ 4	Input
dims	Double precision: const kml_fft_iodim* Single precision: const kml_fftf_iodim* Half precision: const kml_ffth_iodim*	dims is a structure array whose size is rank. dims[i] contains the following members: int n: FFT length of the i-th dimension. int is: interval between successive elements of the i-th dimensional FFT input sequence. int os: interval between successive elements of the i-th dimensional FFT output sequence. Constraint: dims[i].n ≥ 1, for i in 0 to rank - 1.	Input
howmany_rank	int	The memory allocation between multiple rank-dimension FFTs is described by the howmany_dims array of the howmany_rank dimension. howmany_rank indicates the number of dimensions required by the memory access mode for the start address of each rank-dimension FFT to be calculated. Constraint: 0 ≤ howmany_rank ≤ 4	Input
howmany_dims	Double precision: const kml_fft_iodim* Single precision: const kml_fftf_iodim* Half precision: const kml_ffth_iodim*	howmany_dims is a structure array whose size is howmany_rank. howmany_dims[i] contains the following members: int n: number of pending FFTs in the i-th dimension of the howmany_rank dimension space. int is: interval between successive FFT input sequences of the i-th dimension. int os: interval between successive FFT output sequences of the i-th dimension.	Input
ri	Double precision: double* Single precision: float* Half precision: __fp16*	Inputs the real part of the data to be transformed.	Input
ii	Double precision: double* Single precision: float* Half precision: __fp16*	Inputs the imaginary part of the data to be transformed.	Input
ro	Double precision: double* Single precision: float* Half precision: __fp16*	Outputs the real part of the data to be transformed.	Output
io	Double precision: double* Single precision: float* Half precision: __fp16*	Outputs the imaginary part of the data to be transformed.	Output
flags	unsigned int	Planning option, which describes the ESTIMATE or PATIENT mode. KML_FFT_ESTIMATE: ESTIMATE mode KML_FFT_PATIENT: PATIENT mode	Input

Dependencies

C: "kfft.h"

Examples

C interface:

    int rank = 2; 
    kml_fft_iodim *dims; 
    dims = (kml_fft_iodim*)kml_fft_malloc(sizeof(kml_fft_iodim) * rank); 
    dims[0].n = 2; 
    dims[0].is = 3; 
    dims[0].os = 3; 
    dims[1].n = 3; 
    dims[1].is = 1; 
    dims[1].os = 1; 
    int howmany_rank = 1; 
    kml_fft_iodim *howmany_dims; 
    howmany_dims = (kml_fft_iodim*)kml_fft_malloc(sizeof(kml_fft_iodim) * howmany_rank); 
    howmany_dims[0].n = 2; 
    howmany_dims[0].is = 2 * 3; 
    howmany_dims[0].os = 2 * 3; 
    double init[12][2] = {{120, 0}, {8, 8}, {0, 0}, {0, 16}, {0, 16}, {-8, 8}, {-8, 0}, {-8, 8}, {-16, 0}, {0, -16}, {-40, 8}, {-8, -8}}; 
    double *ri; 
    ri = (double*)kml_fft_malloc(sizeof(double) * 12); 
    double *ii; 
    ii = (double*)kml_fft_malloc(sizeof(double) * 12); 
    for (int i = 0; i < 12; i++) { 
        ri[i] = init[i][0]; 
        ii[i] = init[i][1]; 
    } 
    double *ro; 
    ro = (double*)kml_fft_malloc(sizeof(double) * 12); 
    double *io; 
    io = (double*)kml_fft_malloc(sizeof(double) * 12); 
    kml_fft_plan plan; 
    plan = kml_fft_plan_guru_split_dft(rank, dims, howmany_rank, howmany_dims, ri, ii, ro, io, KML_FFT_ESTIMATE); 
    kml_fft_execute_split_dft(plan, ri, ii, ro, io); 
 
    kml_fft_destroy_plan(plan); 
    kml_fft_free(howmany_dims); 
    kml_fft_free(dims); 
    kml_fft_free(ri); 
    kml_fft_free(ii); 
    kml_fft_free(ro); 
    kml_fft_free(io); 
 
    /* 
     * ro = {1.200000e+02, 1.338564e+02, 1.061436e+02, 1.360000e+02, 
     *       1.120000e+02, 1.120000e+02, -8.000000e+01, 4.878461e+01, 
     *       7.215390e+00, 1.600000e+01, -2.692820e+01, -1.307180e+01} 
     */ 
 
    /* 
     * io = {4.800000e+01, -1.385641e+01, 1.385641e+01, -3.200000e+01, 
     *       -8.000000e+00, -8.000000e+00, -8.000000e+00, 7.846097e-01, 
     *       -4.078461e+01, 2.400000e+01, -2.264102e+01, 4.664102e+01} 
     */

Fortran interface:

    INTEGER(C_INT) :: RANK = 2 
    INTEGER(C_INT) :: HOWMANY_RANK = 1 
    TYPE(KML_FFT_IODIM), POINTER :: DIMS(:), HOWMANY_DIMS(:) 
    REAL(C_DOUBLE), DIMENSION(12, 2) :: INIT 
    TYPE(C_DOUBLE), POINTER :: RI(:), II(:), RO(:), IO(:) 
    TYPE(C_PTR) :: PRI, PII, PRO, PIO, PDIMS, PHOWMANY_DIMS 
    INTEGER(C_SIZE_T) :: SIZE1, SIZE2, SIZE3 
    SIZE1 = 8 * 12 
    SIZE2 = 24 * RANK 
    SIZE3 = 24 * HOWMANY_RANK 
    PDIMS = KML_FFT_MALLOC(SIZE2) 
    PHOWMANY_DIMS = KML_FFT_MALLOC(SIZE3) 
    PRI = KML_FFT_MALLOC(SIZE1) 
    PII = KML_FFT_MALLOC(SIZE1) 
    PRO = KML_FFT_MALLOC(SIZE1) 
    PIO = KML_FFT_MALLOC(SIZE1) 
    CALL C_F_POINTER(PRI, RI, SHAPE=[12]) 
    CALL C_F_POINTER(PII, II, SHAPE=[12]) 
    CALL C_F_POINTER(PRO, RO, SHAPE=[12]) 
    CALL C_F_POINTER(PIO, IO, SHAPE=[12]) 
    CALL C_F_POINTER(PDIMS, DIMS, SHAPE=[RANK]) 
    CALL C_F_POINTER(PHOWMANY_DIMS, HOWMANY_DIMS, SHAPE=[HOWMANY_RANK]) 
     
    DIMS(0)%N = 2 
    DIMS(0)%IS = 3 
    DIMS(0)%OS = 3 
    DIMS(1)%N = 3 
    DIMS(1)%IS = 1 
    DIMS(1)%OS = 1 
    HOWMANY_DIMS(0)%N = 2 
    HOWMANY_DIMS(0)%IS = 2 * 3 
    HOWMANY_DIMS(0)%OS = 2 * 3 
    DATA INIT/120, 8, 0, 0, 0, -8, -8, -8, -16, 0, -40, -8, 0, 8, 0, 16, 16, 8, 0, 8, 0, -16, 8, -8/ 
    INTEGER :: I = 1
    DO WHILE(I <= 12) 
        RI(I) = INIT(I, 0) 
        II(I) = INIT(I, 1) 
        I = I + 1
    END DO 
 
    TYPE(C_PTR) :: PLAN 
    PLAN = KML_FFT_PLAN_GURU_SPLIT_DFT(RANK, DIMS, HOWMANY_RANK, HOWMANY_DIMS, RI, II, RO, IO, KML_FFT_ESTIMATE) 
    CALL KML_FFT_EXECUTE_SPLIT_DFT(PLAN, RI, II, RO, IO) 
 
    CALL KML_FFT_DESTROY_PLAN(PLAN) 
    CALL KML_FFT_FREE(PHOWMANY_DIMS) 
    CALL KML_FFT_FREE(PDIMS) 
    CALL KML_FFT_FREE(PRI) 
    CALL KML_FFT_FREE(PII) 
    CALL KML_FFT_FREE(PRO) 
    CALL KML_FFT_FREE(PIO) 
 
    ! 
    ! RO = /1.200000E+02, 1.338564E+02, 1.061436E+02, 1.360000E+02, 
    !       1.120000E+02, 1.120000E+02, -8.000000E+01, 4.878461E+01, 
    !       7.215390E+00, 1.600000E+01, -2.692820E+01, -1.307180E+01/ 
    ! 
 
    ! 
    ! IO = /4.800000E+01, -1.385641E+01, 1.385641E+01, -3.200000E+01, 
    !       -8.000000E+00, -8.000000E+00, -8.000000E+00, 7.846097E-01, 
    !       -4.078461E+01, 2.400000E+01, -2.264102E+01, 4.664102E+01/ 
    !

The plan returned by kml_fft(f)_plan_guru_split_dft can use kml_fft(f)_execute to calculate the plan input or kml_fft(f)_execute_split_dft to calculate a different input. The input of a plan does not need to be initialized, but the input must be valid (cannot be NULL).

Parent topic: C2C Transforms