fft.h

Go to the documentation of this file.

#ifndef CPPAPE_FFT_H
#define CPPAPE_FFT_H
 
#include "baselib.h"
#include "misc.h"
#include <complex>
 
namespace ape
{
    template<typename T>
    class FFT;
 
    template<typename T>
    class FFTBase
    {
    public:
 
        void forward(uarray<std::complex<T>> inout)
        {
            assert(inout.size() == size);
 
            perform(APE_FFT_Forward, inout.data(), inout.data());
        }
 
        void forward(uarray<const std::complex<T>> in, uarray<std::complex<T>> out)
        {
            assert(in.size() == size);
            assert(out.size() == size);
 
            perform(APE_FFT_Forward, in.data(), out.data());
        }
 
        void forwardReal(uarray<const T> in, uarray<std::complex<T>> out)
        {
            assert(in.size() == size);
            assert(out.size() == size);
 
            perform(APE_FFT_Forward, in.data(), out.data());
        }
 
        void inverse(uarray<std::complex<T>> inout)
        {
            assert(inout.size() == size);
 
            perform(APE_FFT_Inverse, inout.data(), inout.data());
        }
 
        void inverse(uarray<const std::complex<T>> in, uarray<std::complex<T>> out)
        {
            assert(in.size() == size);
            assert(out.size() == size);
 
            perform(APE_FFT_Inverse, in.data(), out.data());
        }
 
        void inverseNonScaled(uarray<std::complex<T>> inout)
        {
            assert(inout.size() == size);
 
            perform(APE_FFT_Inverse | APE_FFT_NonScaled, inout.data(), inout.data());
        }
 
        void inverseNonScaled(uarray<const std::complex<T>> in, uarray<std::complex<T>> out)
        {
            assert(in.size() == size);
            assert(out.size() == size);
 
            perform(APE_FFT_Inverse | APE_FFT_NonScaled, in.data(), out.data());
        }
 
        FFTBase(FFTBase&& other)
            : size(other.size), fft(other.fft)
        {
            other.fft = 0;
        }
 
        FFTBase& operator = (FFTBase&& other)
        {
            size = other.size;
            fft = other.fft;
            other.fft = 0;
 
            return *this;
        }
 
        FFTBase& operator = (const FFTBase& other) = delete;
        FFTBase(const FFTBase& other) = delete;
 
        ~FFTBase()
        {
            if(fft != 0)
                getInterface().releaseFFT(&getInterface(), fft);
        }
 
    protected:
 
        FFTBase(std::size_t N, int fft)
            : size(N), fft(fft)
        {
        }
 
    private:
 
        void perform(APE_FFT_Options options, const void* in, void* out)
        {
            assert(fft != 0);
            assert(size != 0);
 
            getInterface().performFFT(&getInterface(), fft, options, in, out);
        }
 
        std::size_t size;
        int fft;
    };
 
    template<>
    class FFT<float> : public FFTBase<float>
    {
    public:
 
        FFT(std::size_t N)
            : FFTBase(N, getInterface().createFFT(&getInterface(), APE_DataType_Single, N))
        {
        }
 
        FFT() : FFTBase(0, 0) {}
    };
 
    template<>
    class FFT<double> : public FFTBase<double>
    {
    public:
 
        FFT(std::size_t N)
            : FFTBase(N, getInterface().createFFT(&getInterface(), APE_DataType_Double, N))
        {
        }
 
        FFT() : FFTBase(0, 0) {}
 
    };
 
}
 
#endif