fft.h

#pragma once
 
#include <dsplib/array.h>
 
#include <memory>
 
namespace dsplib {
 
class FftPlanC
{
public:
    virtual ~FftPlanC() = default;
 
    [[nodiscard]] virtual arr_cmplx solve(span_t<cmplx_t> x) const = 0;
 
    virtual void solve(span_t<cmplx_t> x, mut_span_t<cmplx_t> r) const {
        r = this->solve(x);
    }
 
    //inplace FFT implementation
    virtual void solve(inplace_cmplx inp) const {
        //default non optimal implementation with temp array
        auto x = inp.get();
        const auto y = this->solve(x);
        x.assign(y);
    }
 
    [[nodiscard]] virtual int size() const noexcept = 0;
};
 
class FftPlanR
{
public:
    virtual ~FftPlanR() = default;
 
    [[nodiscard]] virtual arr_cmplx solve(span_t<real_t> x) const = 0;
 
    virtual void solve(span_t<real_t> x, mut_span_t<cmplx_t> r) const {
        r = this->solve(x);
    }
 
    [[nodiscard]] virtual int size() const noexcept = 0;
};
 
std::shared_ptr<FftPlanC> fft_plan_c(int n);
 
std::shared_ptr<FftPlanR> fft_plan_r(int n);
 
arr_cmplx fft(span_t<cmplx_t> x);
 
//n-point DFT
// if x.size() is less than n, then X is padded with trailing zeros to length n
// if x.size() is greater than n, then x is truncated to length n
arr_cmplx fft(span_t<cmplx_t> x, int n);
 
//Fast Fourier Transform (real)
arr_cmplx fft(span_t<real_t> x);
arr_cmplx fft(span_t<real_t> x, int n);
 
arr_cmplx rfft(span_t<real_t> x);          // equal `fft(x)`
arr_cmplx rfft(span_t<real_t> x, int n);   // equal `fft(x, n)`
 
}   // namespace dsplib