#include <dsp.h>

Public Member Functions
	cfft_engine (int _n)

void	inplace (complex< T > *data, bool reverse=false)

Public Attributes
const int	n

Private Attributes
int	logn

int *	bitrev

complex< T > *	omega

complex< T > *	omega_rev

float	invsqrtn

Detailed Description

template<typename T>
struct leansdr::cfft_engine< T >

Definition at line 62 of file dsp.h.

Constructor & Destructor Documentation

◆ cfft_engine()

template<typename T>

leansdr::cfft_engine< T >::cfft_engine ( int _n )

inline

Definition at line 65 of file dsp.h.

                         : n(_n), invsqrtn(1.0 / sqrt(n))
     {
         // Compute log2(n)
         logn = 0;
         for (int t = n; t > 1; t >>= 1)
             ++logn;
         // Bit reversal
         bitrev = new int[n];
         for (int i = 0; i < n; ++i)
         {
             bitrev[i] = 0;
             for (int b = 0; b < logn; ++b)
                 bitrev[i] = (bitrev[i] << 1) | ((i >> b) & 1);
         }
         // Float constants
         omega = new complex<T>[n];
         omega_rev = new complex<T>[n];
         for (int i = 0; i < n; ++i)
         {
             float a = 2.0 * M_PI * i / n;
             omega_rev[i].re = (omega[i].re = cosf(a));
             omega_rev[i].im = -(omega[i].im = sinf(a));
         }
     }

Member Function Documentation

◆ inplace()

template<typename T>

void leansdr::cfft_engine< T >::inplace	(	complex< T > *	data,
		bool	reverse = `false`
	)

inline

Definition at line 89 of file dsp.h.

Referenced by leansdr::auto_notch< leansdr::f32 >::detect(), leansdr::cnr_fft< leansdr::f32 >::do_cnr(), and leansdr::spectrum< T, NFFT >::do_spectrum().

     {
         // Bit-reversal permutation
         for (int i = 0; i < n; ++i)
         {
             int r = bitrev[i];
             if (r < i)
             {
                 complex<T> tmp = data[i];
                 data[i] = data[r];
                 data[r] = tmp;
             }
         }
         complex<T> *om = reverse ? omega_rev : omega;
         // Danielson-Lanczos
         for (int i = 0; i < logn; ++i)
         {
             int hbs = 1 << i;
             int dom = 1 << (logn - 1 - i);
             for (int j = 0; j < dom; ++j)
             {
                 int p = j * hbs * 2, q = p + hbs;
                 for (int k = 0; k < hbs; ++k)
                 {
                     complex<T> &w = om[k * dom];
                     complex<T> &dqk = data[q + k];
                     complex<T> x(w.re * dqk.re - w.im * dqk.im,
                                  w.re * dqk.im + w.im * dqk.re);
                     data[q + k].re = data[p + k].re - x.re;
                     data[q + k].im = data[p + k].im - x.im;
                     data[p + k].re = data[p + k].re + x.re;
                     data[p + k].im = data[p + k].im + x.im;
                 }
             }
         }
         if (reverse)
         {
             float invn = 1.0 / n;
             for (int i = 0; i < n; ++i)
             {
                 data[i].re *= invn;
                 data[i].im *= invn;
             }
         }
     }