FFTPlanBase.h

#pragma once

#include <complex>
#include <memory>
#include <type_traits>

#include "FFTWWrapper.h"
#include "Threads.h"

namespace isce3 { namespace fft { namespace detail {

template<int Sign, typename T>
class FFTPlanBase {
public:

    static_assert( Sign == FFTW_FORWARD || Sign == FFTW_BACKWARD, "" );
    static_assert( std::is_same<T, float>::value || std::is_same<T, double>::value, "" );

    FFTPlanBase();

    FFTPlanBase(std::complex<T> * out,
                std::complex<T> * in,
                int n,
                int batch = 1,
                unsigned flags = FFTW_MEASURE,
                int threads = getMaxThreads());

    template<int Rank>
    FFTPlanBase(std::complex<T> * out,
                std::complex<T> * in,
                const int (&n)[Rank],
                int batch = 1,
                unsigned flags = FFTW_MEASURE,
                int threads = getMaxThreads());

    FFTPlanBase(std::complex<T> * out,
                std::complex<T> * in,
                int n,
                int nembed,
                int stride,
                int dist,
                int batch = 1,
                unsigned flags = FFTW_MEASURE,
                int threads = getMaxThreads());

    template<int Rank>
    FFTPlanBase(std::complex<T> * out,
                std::complex<T> * in,
                const int (&n)[Rank],
                const int (&nembed)[Rank],
                int stride,
                int dist,
                int batch = 1,
                unsigned flags = FFTW_MEASURE,
                int threads = getMaxThreads());

    FFTPlanBase(std::complex<T> * out,
                std::complex<T> * in,
                int n,
                int inembed,
                int istride,
                int idist,
                int onembed,
                int ostride,
                int odist,
                int batch = 1,
                unsigned flags = FFTW_MEASURE,
                int threads = getMaxThreads());

    template<int Rank>
    FFTPlanBase(std::complex<T> * out,
                std::complex<T> * in,
                const int (&n)[Rank],
                const int (&inembed)[Rank],
                int istride,
                int idist,
                const int (&onembed)[Rank],
                int ostride,
                int odist,
                int batch = 1,
                unsigned flags = FFTW_MEASURE,
                int threads = getMaxThreads());

    explicit operator bool() const { return *_plan; }

    void execute() const;

protected:

    using fftw_plan_t = typename FFTWPlanType<T>::plan_t;

    template<typename U, typename V>
    FFTPlanBase(U * out,
                V * in,
                const int * n,
                const int * inembed,
                int istride,
                int idist,
                const int * onembed,
                int ostride,
                int odist,
                int batch,
                unsigned flags,
                int rank,
                int sign,
                int threads);

    std::shared_ptr<fftw_plan_t> _plan;
};

template<int N>
int product(const int (&arr)[N]);

}}}

#define ISCE_FFT_DETAIL_FFTPLANBASE_ICC
#include "FFTPlanBase.icc"
#undef ISCE_FFT_DETAIL_FFTPLANBASE_ICC