#include <ei_kissfft_impl.h>

Public Types
typedef Scalar_	Scalar

typedef std::complex< Scalar >	Complex

Public Member Functions
void	make_twiddles (int nfft, bool inverse)

void	factorize (int nfft)

template<typename Src_ >
void	work (int stage, Complex xout, const Src_ xin, size_t fstride, size_t in_stride)

void	bfly2 (Complex *Fout, const size_t fstride, int m)

void	bfly4 (Complex *Fout, const size_t fstride, const size_t m)

void	bfly3 (Complex *Fout, const size_t fstride, const size_t m)

void	bfly5 (Complex *Fout, const size_t fstride, const size_t m)

void	bfly_generic (Complex *Fout, const size_t fstride, int m, int p)

Public Attributes
std::vector< Complex >	m_twiddles

std::vector< int >	m_stageRadix

std::vector< int >	m_stageRemainder

std::vector< Complex >	m_scratchBuf

bool	m_inverse

Static Public Attributes
static const Scalar	m_pi4

Member Typedef Documentation

◆ Complex

template<typename Scalar_ >

typedef std::complex<Scalar> Eigen::internal::kiss_cpx_fft< Scalar_ >::Complex

◆ Scalar

template<typename Scalar_ >

typedef Scalar_ Eigen::internal::kiss_cpx_fft< Scalar_ >::Scalar

Member Function Documentation

◆ bfly2()

template<typename Scalar_ >

void Eigen::internal::kiss_cpx_fft< Scalar_ >::bfly2	(	Complex *	Fout,
		const size_t	fstride,
		int	m
	)

inline

                                                                 {
     for (int k = 0; k < m; ++k) {
       Complex t = Fout[m + k] * m_twiddles[k * fstride];
       Fout[m + k] = Fout[k] - t;
       Fout[k] += t;
     }
   }

References k, m, Eigen::internal::kiss_cpx_fft< Scalar_ >::m_twiddles, and plotPSD::t.

Referenced by Eigen::internal::kiss_cpx_fft< Scalar_ >::work().

◆ bfly3()

template<typename Scalar_ >

void Eigen::internal::kiss_cpx_fft< Scalar_ >::bfly3	(	Complex *	Fout,
		const size_t	fstride,
		const size_t	m
	)

inline

                                                                          {
     size_t k = m;
     const size_t m2 = 2 * m;
     Complex *tw1, *tw2;
     Complex scratch[5];
     Complex epi3;
     epi3 = m_twiddles[fstride * m];
  
     tw1 = tw2 = &m_twiddles[0];
  
     do {
       scratch[1] = Fout[m] * *tw1;
       scratch[2] = Fout[m2] * *tw2;
  
       scratch[3] = scratch[1] + scratch[2];
       scratch[0] = scratch[1] - scratch[2];
       tw1 += fstride;
       tw2 += fstride * 2;
       Fout[m] = Complex(Fout->real() - Scalar(.5) * scratch[3].real(), Fout->imag() - Scalar(.5) * scratch[3].imag());
       scratch[0] *= epi3.imag();
       *Fout += scratch[3];
       Fout[m2] = Complex(Fout[m].real() + scratch[0].imag(), Fout[m].imag() - scratch[0].real());
       Fout[m] += Complex(-scratch[0].imag(), scratch[0].real());
       ++Fout;
     } while (--k);
   }

References Eigen::imag(), k, m, m2(), Eigen::internal::kiss_cpx_fft< Scalar_ >::m_twiddles, and Eigen::real().

Referenced by Eigen::internal::kiss_cpx_fft< Scalar_ >::work().

◆ bfly4()

template<typename Scalar_ >

void Eigen::internal::kiss_cpx_fft< Scalar_ >::bfly4	(	Complex *	Fout,
		const size_t	fstride,
		const size_t	m
	)

inline

                                                                          {
     Complex scratch[6];
     int negative_if_inverse = m_inverse * -2 + 1;
     for (size_t k = 0; k < m; ++k) {
       scratch[0] = Fout[k + m] * m_twiddles[k * fstride];
       scratch[1] = Fout[k + 2 * m] * m_twiddles[k * fstride * 2];
       scratch[2] = Fout[k + 3 * m] * m_twiddles[k * fstride * 3];
       scratch[5] = Fout[k] - scratch[1];
  
       Fout[k] += scratch[1];
       scratch[3] = scratch[0] + scratch[2];
       scratch[4] = scratch[0] - scratch[2];
       scratch[4] = Complex(scratch[4].imag() * negative_if_inverse, -scratch[4].real() * negative_if_inverse);
  
       Fout[k + 2 * m] = Fout[k] - scratch[3];
       Fout[k] += scratch[3];
       Fout[k + m] = scratch[5] + scratch[4];
       Fout[k + 3 * m] = scratch[5] - scratch[4];
     }
   }

References Eigen::imag(), k, m, Eigen::internal::kiss_cpx_fft< Scalar_ >::m_inverse, Eigen::internal::kiss_cpx_fft< Scalar_ >::m_twiddles, and Eigen::real().

Referenced by Eigen::internal::kiss_cpx_fft< Scalar_ >::work().

◆ bfly5()

template<typename Scalar_ >

void Eigen::internal::kiss_cpx_fft< Scalar_ >::bfly5	(	Complex *	Fout,
		const size_t	fstride,
		const size_t	m
	)

inline

                                                                          {
     Complex *Fout0, *Fout1, *Fout2, *Fout3, *Fout4;
     size_t u;
     Complex scratch[13];
     Complex *twiddles = &m_twiddles[0];
     Complex *tw;
     Complex ya, yb;
     ya = twiddles[fstride * m];
     yb = twiddles[fstride * 2 * m];
  
     Fout0 = Fout;
     Fout1 = Fout0 + m;
     Fout2 = Fout0 + 2 * m;
     Fout3 = Fout0 + 3 * m;
     Fout4 = Fout0 + 4 * m;
  
     tw = twiddles;
     for (u = 0; u < m; ++u) {
       scratch[0] = *Fout0;
  
       scratch[1] = *Fout1 * tw[u * fstride];
       scratch[2] = *Fout2 * tw[2 * u * fstride];
       scratch[3] = *Fout3 * tw[3 * u * fstride];
       scratch[4] = *Fout4 * tw[4 * u * fstride];
  
       scratch[7] = scratch[1] + scratch[4];
       scratch[10] = scratch[1] - scratch[4];
       scratch[8] = scratch[2] + scratch[3];
       scratch[9] = scratch[2] - scratch[3];
  
       *Fout0 += scratch[7];
       *Fout0 += scratch[8];
  
       scratch[5] = scratch[0] + Complex((scratch[7].real() * ya.real()) + (scratch[8].real() * yb.real()),
                                         (scratch[7].imag() * ya.real()) + (scratch[8].imag() * yb.real()));
  
       scratch[6] = Complex((scratch[10].imag() * ya.imag()) + (scratch[9].imag() * yb.imag()),
                            -(scratch[10].real() * ya.imag()) - (scratch[9].real() * yb.imag()));
  
       *Fout1 = scratch[5] - scratch[6];
       *Fout4 = scratch[5] + scratch[6];
  
       scratch[11] = scratch[0] + Complex((scratch[7].real() * yb.real()) + (scratch[8].real() * ya.real()),
                                          (scratch[7].imag() * yb.real()) + (scratch[8].imag() * ya.real()));
  
       scratch[12] = Complex(-(scratch[10].imag() * yb.imag()) + (scratch[9].imag() * ya.imag()),
                             (scratch[10].real() * yb.imag()) - (scratch[9].real() * ya.imag()));
  
       *Fout2 = scratch[11] + scratch[12];
       *Fout3 = scratch[11] - scratch[12];
  
       ++Fout0;
       ++Fout1;
       ++Fout2;
       ++Fout3;
       ++Fout4;
     }
   }

References Eigen::imag(), m, Eigen::internal::kiss_cpx_fft< Scalar_ >::m_twiddles, and Eigen::real().

Referenced by Eigen::internal::kiss_cpx_fft< Scalar_ >::work().

◆ bfly_generic()

template<typename Scalar_ >

void Eigen::internal::kiss_cpx_fft< Scalar_ >::bfly_generic	(	Complex *	Fout,
		const size_t	fstride,
		int	m,
		int	p
	)

inline

                                                                               {
     int u, k, q1, q;
     Complex *twiddles = &m_twiddles[0];
     Complex t;
     int Norig = static_cast<int>(m_twiddles.size());
     Complex *scratchbuf = &m_scratchBuf[0];
  
     for (u = 0; u < m; ++u) {
       k = u;
       for (q1 = 0; q1 < p; ++q1) {
         scratchbuf[q1] = Fout[k];
         k += m;
       }
  
       k = u;
       for (q1 = 0; q1 < p; ++q1) {
         int twidx = 0;
         Fout[k] = scratchbuf[0];
         for (q = 1; q < p; ++q) {
           twidx += static_cast<int>(fstride) * k;
           if (twidx >= Norig) twidx -= Norig;
           t = scratchbuf[q] * twiddles[twidx];
           Fout[k] += t;
         }
         k += m;
       }
     }
   }

References k, m, Eigen::internal::kiss_cpx_fft< Scalar_ >::m_scratchBuf, Eigen::internal::kiss_cpx_fft< Scalar_ >::m_twiddles, p, Eigen::numext::q, and plotPSD::t.

Referenced by Eigen::internal::kiss_cpx_fft< Scalar_ >::work().

◆ factorize()

template<typename Scalar_ >

void Eigen::internal::kiss_cpx_fft< Scalar_ >::factorize ( int nfft )

inline

                            {
     // start factoring out 4's, then 2's, then 3,5,7,9,...
     int n = nfft;
     int p = 4;
     do {
       while (n % p) {
         switch (p) {
           case 4:
             p = 2;
             break;
           case 2:
             p = 3;
             break;
           default:
             p += 2;
             break;
         }
         if (p * p > n) p = n;  // impossible to have a factor > sqrt(n)
       }
       n /= p;
       m_stageRadix.push_back(p);
       m_stageRemainder.push_back(n);
       if (p > 5) m_scratchBuf.resize(p);  // scratchbuf will be needed in bfly_generic
     } while (n > 1);
   }

References Eigen::internal::kiss_cpx_fft< Scalar_ >::m_scratchBuf, Eigen::internal::kiss_cpx_fft< Scalar_ >::m_stageRadix, Eigen::internal::kiss_cpx_fft< Scalar_ >::m_stageRemainder, n, and p.

Referenced by Eigen::internal::kissfft_impl< Scalar_ >::get_plan().

◆ make_twiddles()

template<typename Scalar_ >

void Eigen::internal::kiss_cpx_fft< Scalar_ >::make_twiddles	(	int	nfft,
		bool	inverse
	)

inline

                                                     {
     using numext::cos;
     using numext::sin;
     m_inverse = inverse;
     m_twiddles.resize(nfft);
     Scalar phinc = m_pi4 / nfft;
     Scalar flip = inverse ? Scalar(1) : Scalar(-1);
     m_twiddles[0] = Complex(Scalar(1), Scalar(0));
     if ((nfft & 1) == 0) m_twiddles[nfft / 2] = Complex(Scalar(-1), Scalar(0));
     int i = 1;
     for (; i * 8 < nfft; ++i) {
       Scalar c = Scalar(cos(i * 8 * phinc));
       Scalar s = Scalar(sin(i * 8 * phinc));
       m_twiddles[i] = Complex(c, s * flip);
       m_twiddles[nfft - i] = Complex(c, -s * flip);
     }
     for (; i * 4 < nfft; ++i) {
       Scalar c = Scalar(cos((2 * nfft - 8 * i) * phinc));
       Scalar s = Scalar(sin((2 * nfft - 8 * i) * phinc));
       m_twiddles[i] = Complex(s, c * flip);
       m_twiddles[nfft - i] = Complex(s, -c * flip);
     }
     for (; i * 8 < 3 * nfft; ++i) {
       Scalar c = Scalar(cos((8 * i - 2 * nfft) * phinc));
       Scalar s = Scalar(sin((8 * i - 2 * nfft) * phinc));
       m_twiddles[i] = Complex(-s, c * flip);
       m_twiddles[nfft - i] = Complex(-s, -c * flip);
     }
     for (; i * 2 < nfft; ++i) {
       Scalar c = Scalar(cos((4 * nfft - 8 * i) * phinc));
       Scalar s = Scalar(sin((4 * nfft - 8 * i) * phinc));
       m_twiddles[i] = Complex(-c, s * flip);
       m_twiddles[nfft - i] = Complex(-c, -s * flip);
     }
   }

References calibrate::c, cos(), Eigen::numext::cos(), i, inverse(), Eigen::internal::kiss_cpx_fft< Scalar_ >::m_inverse, Eigen::internal::kiss_cpx_fft< Scalar_ >::m_pi4, Eigen::internal::kiss_cpx_fft< Scalar_ >::m_twiddles, s, sin(), and Eigen::numext::sin().

Referenced by Eigen::internal::kissfft_impl< Scalar_ >::get_plan().

◆ work()

template<typename Scalar_ >

template<typename Src_ >

void Eigen::internal::kiss_cpx_fft< Scalar_ >::work	(	int	stage,
		Complex *	xout,
		const Src_ *	xin,
		size_t	fstride,
		size_t	in_stride
	)

inline

                                                                                                 {
     int p = m_stageRadix[stage];
     int m = m_stageRemainder[stage];
     Complex *Fout_beg = xout;
     Complex *Fout_end = xout + p * m;
  
     if (m > 1) {
       do {
         // recursive call:
         // DFT of size m*p performed by doing
         // p instances of smaller DFTs of size m,
         // each one takes a decimated version of the input
         work(stage + 1, xout, xin, fstride * p, in_stride);
         xin += fstride * in_stride;
       } while ((xout += m) != Fout_end);
     } else {
       do {
         *xout = *xin;
         xin += fstride * in_stride;
       } while (++xout != Fout_end);
     }
     xout = Fout_beg;
  
     // recombine the p smaller DFTs
     switch (p) {
       case 2:
         bfly2(xout, fstride, m);
         break;
       case 3:
         bfly3(xout, fstride, m);
         break;
       case 4:
         bfly4(xout, fstride, m);
         break;
       case 5:
         bfly5(xout, fstride, m);
         break;
       default:
         bfly_generic(xout, fstride, m, p);
         break;
     }
   }