Function fft_c2r

src/backend/cpu/fft.cpp:155–216

template<typename Tr, typename Tc>
Array<Tr> fft_c2r(const Array<Tc> &in, const dim4 &odims, const int rank) {
    Array<Tr> out = createEmptyArray<Tr>(odims);

    auto func = [=](Param<Tr> out, const af::dim4 oDataDims, CParam<Tc> in,
                    const af::dim4 iDataDims, const af::dim4 odims) {
        auto t_dims    = computeDims(rank, odims);
        auto in_embed  = computeDims(rank, iDataDims);
        auto out_embed = computeDims(rank, oDataDims);

        const af::dim4 istrides = in.strides();
        const af::dim4 ostrides = out.strides();

        using ctype_t = typename fftw_real_transform<Tr, Tc>::ctype_t;
        using plan_t  = typename fftw_real_transform<Tr, Tc>::plan_t;
        plan_t plan;

        fftw_real_transform<Tr, Tc> transform;

        int batch = 1;
        for (int i = rank; i < 4; i++) { batch *= odims[i]; }

        // By default, fftw estimate flag is sufficient for most transforms.
        // However, complex to real transforms modify the input data memory
        // while performing the transformation. To avoid that, we need to pass
        // FFTW_PRESERVE_INPUT also. This flag however only works for 1D
        // transforms and for higher level transformations, a copy of input
        // data is passed onto the upstream FFTW calls.
        unsigned int flags = FFTW_ESTIMATE;  // NOLINT(hicpp-signed-bitwise)
        if (rank == 1) {
            flags |= FFTW_PRESERVE_INPUT;  // NOLINT(hicpp-signed-bitwise)
        }

        plan = transform.create(
            rank, t_dims.data(), batch,
            reinterpret_cast<ctype_t *>(const_cast<Tc *>(in.get())),
            in_embed.data(), static_cast<int>(istrides[0]),
            static_cast<int>(istrides[rank]), out.get(), out_embed.data(),
            static_cast<int>(ostrides[0]), static_cast<int>(ostrides[rank]),
            flags);

        transform.execute(plan);
        transform.destroy(plan);
    };

#ifdef USE_MKL
    getQueue().enqueue(func, out, out.getDataDims(), in, in.getDataDims(),
                       odims);
#else
    if (rank > 1 || odims.ndims() > 1) {
        // FFTW does not have a input preserving algorithm for multidimensional
        // c2r FFTs
        Array<Tc> in_ = copyArray<Tc>(in);
        getQueue().enqueue(func, out, out.getDataDims(), in_, in.getDataDims(),
                           odims);
    } else {
        getQueue().enqueue(func, out, out.getDataDims(), in, in.getDataDims(),
                           odims);
    }