SDRAngel  4.11.5
Developer docs for <a href="https://github.com/f4exb/sdrangel">SDRangel<\a>, an Open Source Qt5 / OpenGL 3.0+ SDR and signal analyzer frontend to various hardware.
Public Types | Public Member Functions | Private Member Functions | Private Attributes | List of all members
kissfft< T_Scalar, T_Complex, T_traits > Class Template Reference

#include <kissfft.h>

Public Types

typedef T_traits traits_type
 
typedef traits_type::scalar_type scalar_type
 
typedef traits_type::cpx_type cpx_type
 

Public Member Functions

 kissfft ()
 
 kissfft (int nfft, bool inverse, const traits_type &traits=traits_type())
 
void configure (int nfft, bool inverse, const traits_type &traits=traits_type())
 
void transform (const cpx_type *src, cpx_type *dst)
 

Private Member Functions

void kf_work (int stage, cpx_type *Fout, const cpx_type *f, size_t fstride, size_t in_stride)
 
void C_ADD (cpx_type &c, const cpx_type &a, const cpx_type &b)
 
void C_MUL (cpx_type &c, const cpx_type &a, const cpx_type &b)
 
void C_SUB (cpx_type &c, const cpx_type &a, const cpx_type &b)
 
void C_ADDTO (cpx_type &c, const cpx_type &a)
 
void C_FIXDIV (cpx_type &, int)
 
scalar_type S_MUL (const scalar_type &a, const scalar_type &b)
 
scalar_type HALF_OF (const scalar_type &a)
 
void C_MULBYSCALAR (cpx_type &c, const scalar_type &a)
 
void kf_bfly2 (cpx_type *Fout, const size_t fstride, int m)
 
void kf_bfly4 (cpx_type *Fout, const size_t fstride, const size_t m)
 
void kf_bfly3 (cpx_type *Fout, const size_t fstride, const size_t m)
 
void kf_bfly5 (cpx_type *Fout, const size_t fstride, const size_t m)
 
void kf_bfly_generic (cpx_type *Fout, const size_t fstride, int m, int p)
 

Private Attributes

int _nfft
 
bool _inverse
 
std::vector< cpx_type > _twiddles
 
std::vector< int > _stageRadix
 
std::vector< int > _stageRemainder
 
traits_type _traits
 

Detailed Description

template<typename T_Scalar, typename T_Complex, typename T_traits = kissfft_utils::traits<T_Scalar, T_Complex>>
class kissfft< T_Scalar, T_Complex, T_traits >

Definition at line 93 of file kissfft.h.

Member Typedef Documentation

◆ cpx_type

template<typename T_Scalar, typename T_Complex, typename T_traits = kissfft_utils::traits<T_Scalar, T_Complex>>
typedef traits_type::cpx_type kissfft< T_Scalar, T_Complex, T_traits >::cpx_type

Definition at line 97 of file kissfft.h.

◆ scalar_type

template<typename T_Scalar, typename T_Complex, typename T_traits = kissfft_utils::traits<T_Scalar, T_Complex>>
typedef traits_type::scalar_type kissfft< T_Scalar, T_Complex, T_traits >::scalar_type

Definition at line 96 of file kissfft.h.

◆ traits_type

template<typename T_Scalar, typename T_Complex, typename T_traits = kissfft_utils::traits<T_Scalar, T_Complex>>
typedef T_traits kissfft< T_Scalar, T_Complex, T_traits >::traits_type

Definition at line 95 of file kissfft.h.

Constructor & Destructor Documentation

◆ kissfft() [1/2]

template<typename T_Scalar, typename T_Complex, typename T_traits = kissfft_utils::traits<T_Scalar, T_Complex>>
kissfft< T_Scalar, T_Complex, T_traits >::kissfft ( )
inline

Definition at line 99 of file kissfft.h.

100  {
101  }

◆ kissfft() [2/2]

template<typename T_Scalar, typename T_Complex, typename T_traits = kissfft_utils::traits<T_Scalar, T_Complex>>
kissfft< T_Scalar, T_Complex, T_traits >::kissfft ( int  nfft,
bool  inverse,
const traits_type &  traits = traits_type() 
)
inline

Definition at line 103 of file kissfft.h.

103  :
104  _nfft(nfft), _inverse(inverse), _traits(traits)
105  {
106  _traits.prepare(_twiddles, _nfft, _inverse, _stageRadix, _stageRemainder);
107  }
kissfft::_nfft
int _nfft
Definition: kissfft.h:384
kissfft::_stageRadix
std::vector< int > _stageRadix
Definition: kissfft.h:387
kissfft::_twiddles
std::vector< cpx_type > _twiddles
Definition: kissfft.h:386
kissfft::_stageRemainder
std::vector< int > _stageRemainder
Definition: kissfft.h:388
kissfft::_traits
traits_type _traits
Definition: kissfft.h:389
kissfft::_inverse
bool _inverse
Definition: kissfft.h:385

Member Function Documentation

◆ C_ADD()

template<typename T_Scalar, typename T_Complex, typename T_traits = kissfft_utils::traits<T_Scalar, T_Complex>>
void kissfft< T_Scalar, T_Complex, T_traits >::C_ADD ( cpx_type &  c,
const cpx_type &  a,
const cpx_type &  b 
)
inlineprivate

Definition at line 173 of file kissfft.h.

174  {
175  c = a + b;
176  }

◆ C_ADDTO()

template<typename T_Scalar, typename T_Complex, typename T_traits = kissfft_utils::traits<T_Scalar, T_Complex>>
void kissfft< T_Scalar, T_Complex, T_traits >::C_ADDTO ( cpx_type &  c,
const cpx_type &  a 
)
inlineprivate

Definition at line 186 of file kissfft.h.

187  {
188  c += a;
189  }

◆ C_FIXDIV()

template<typename T_Scalar, typename T_Complex, typename T_traits = kissfft_utils::traits<T_Scalar, T_Complex>>
void kissfft< T_Scalar, T_Complex, T_traits >::C_FIXDIV ( cpx_type &  ,
int   
)
inlineprivate

Definition at line 190 of file kissfft.h.

191  {
192  } // NO-OP for float types

◆ C_MUL()

template<typename T_Scalar, typename T_Complex, typename T_traits = kissfft_utils::traits<T_Scalar, T_Complex>>
void kissfft< T_Scalar, T_Complex, T_traits >::C_MUL ( cpx_type &  c,
const cpx_type &  a,
const cpx_type &  b 
)
inlineprivate

Definition at line 177 of file kissfft.h.

178  {
179  //c = a * b;
180  c = cpx_type(a.real() * b.real() - a.imag() * b.imag(), a.real() * b.imag() + a.imag() * b.real());
181  }
kissfft::cpx_type
traits_type::cpx_type cpx_type
Definition: kissfft.h:97

◆ C_MULBYSCALAR()

template<typename T_Scalar, typename T_Complex, typename T_traits = kissfft_utils::traits<T_Scalar, T_Complex>>
void kissfft< T_Scalar, T_Complex, T_traits >::C_MULBYSCALAR ( cpx_type &  c,
const scalar_type &  a 
)
inlineprivate

Definition at line 201 of file kissfft.h.

202  {
203  c *= a;
204  }

◆ C_SUB()

template<typename T_Scalar, typename T_Complex, typename T_traits = kissfft_utils::traits<T_Scalar, T_Complex>>
void kissfft< T_Scalar, T_Complex, T_traits >::C_SUB ( cpx_type &  c,
const cpx_type &  a,
const cpx_type &  b 
)
inlineprivate

Definition at line 182 of file kissfft.h.

183  {
184  c = a - b;
185  }

◆ configure()

template<typename T_Scalar, typename T_Complex, typename T_traits = kissfft_utils::traits<T_Scalar, T_Complex>>
void kissfft< T_Scalar, T_Complex, T_traits >::configure ( int  nfft,
bool  inverse,
const traits_type &  traits = traits_type() 
)
inline

Definition at line 109 of file kissfft.h.

Referenced by KissEngine::configure().

110  {
111  _twiddles.clear();
112  _stageRadix.clear();
113  _stageRemainder.clear();
114 
115  _nfft = nfft;
116  _inverse = inverse;
117  _traits = traits;
118  _traits.prepare(_twiddles, _nfft, _inverse, _stageRadix, _stageRemainder);
119  }
kissfft::_nfft
int _nfft
Definition: kissfft.h:384
kissfft::_stageRadix
std::vector< int > _stageRadix
Definition: kissfft.h:387
kissfft::_twiddles
std::vector< cpx_type > _twiddles
Definition: kissfft.h:386
kissfft::_stageRemainder
std::vector< int > _stageRemainder
Definition: kissfft.h:388
kissfft::_traits
traits_type _traits
Definition: kissfft.h:389
kissfft::_inverse
bool _inverse
Definition: kissfft.h:385
+ Here is the caller graph for this function:

◆ HALF_OF()

template<typename T_Scalar, typename T_Complex, typename T_traits = kissfft_utils::traits<T_Scalar, T_Complex>>
scalar_type kissfft< T_Scalar, T_Complex, T_traits >::HALF_OF ( const scalar_type &  a)
inlineprivate

Definition at line 197 of file kissfft.h.

198  {
199  return a * .5;
200  }

◆ kf_bfly2()

template<typename T_Scalar, typename T_Complex, typename T_traits = kissfft_utils::traits<T_Scalar, T_Complex>>
void kissfft< T_Scalar, T_Complex, T_traits >::kf_bfly2 ( cpx_type *  Fout,
const size_t  fstride,
int  m 
)
inlineprivate

Definition at line 206 of file kissfft.h.

207  {
208  for(int k = 0; k < m; ++k) {
209  //cpx_type t = Fout[m + k] * _traits.twiddle(k * fstride);
210  cpx_type t;
211  C_MUL(t, Fout[m + k], _traits.twiddle(k * fstride));
212  Fout[m + k] = Fout[k] - t;
213  Fout[k] += t;
214  }
215  }
kissfft::cpx_type
traits_type::cpx_type cpx_type
Definition: kissfft.h:97
kissfft::C_MUL
void C_MUL(cpx_type &c, const cpx_type &a, const cpx_type &b)
Definition: kissfft.h:177
kissfft::_traits
traits_type _traits
Definition: kissfft.h:389

◆ kf_bfly3()

template<typename T_Scalar, typename T_Complex, typename T_traits = kissfft_utils::traits<T_Scalar, T_Complex>>
void kissfft< T_Scalar, T_Complex, T_traits >::kf_bfly3 ( cpx_type *  Fout,
const size_t  fstride,
const size_t  m 
)
inlineprivate

Definition at line 240 of file kissfft.h.

241  {
242  size_t k = m;
243  const size_t m2 = 2 * m;
244  cpx_type* tw1;
245  cpx_type* tw2;
246  cpx_type scratch[5];
247  cpx_type epi3;
248  epi3 = _twiddles[fstride * m];
249  tw1 = tw2 = &_twiddles[0];
250 
251  do {
252  C_FIXDIV(*Fout, 3);
253  C_FIXDIV(Fout[m], 3);
254  C_FIXDIV(Fout[m2], 3);
255 
256  C_MUL(scratch[1], Fout[m], *tw1);
257  C_MUL(scratch[2], Fout[m2], *tw2);
258 
259  C_ADD(scratch[3], scratch[1], scratch[2]);
260  C_SUB(scratch[0], scratch[1], scratch[2]);
261  tw1 += fstride;
262  tw2 += fstride * 2;
263 
264  Fout[m] = cpx_type(Fout->real() - HALF_OF(scratch[3].real()), Fout->imag() - HALF_OF(scratch[3].imag()));
265 
266  C_MULBYSCALAR(scratch[0], epi3.imag());
267 
268  C_ADDTO(*Fout, scratch[3]);
269 
270  Fout[m2] = cpx_type(Fout[m].real() + scratch[0].imag(), Fout[m].imag() - scratch[0].real());
271 
272  C_ADDTO(Fout[m], cpx_type(-scratch[0].imag(), scratch[0].real()));
273  ++Fout;
274  } while(--k);
275  }
kissfft::C_SUB
void C_SUB(cpx_type &c, const cpx_type &a, const cpx_type &b)
Definition: kissfft.h:182
kissfft::cpx_type
traits_type::cpx_type cpx_type
Definition: kissfft.h:97
kissfft::HALF_OF
scalar_type HALF_OF(const scalar_type &a)
Definition: kissfft.h:197
kissfft::_twiddles
std::vector< cpx_type > _twiddles
Definition: kissfft.h:386
kissfft::C_ADD
void C_ADD(cpx_type &c, const cpx_type &a, const cpx_type &b)
Definition: kissfft.h:173
kissfft::C_MUL
void C_MUL(cpx_type &c, const cpx_type &a, const cpx_type &b)
Definition: kissfft.h:177
kissfft::C_FIXDIV
void C_FIXDIV(cpx_type &, int)
Definition: kissfft.h:190
kissfft::C_MULBYSCALAR
void C_MULBYSCALAR(cpx_type &c, const scalar_type &a)
Definition: kissfft.h:201
kissfft::C_ADDTO
void C_ADDTO(cpx_type &c, const cpx_type &a)
Definition: kissfft.h:186

◆ kf_bfly4()

template<typename T_Scalar, typename T_Complex, typename T_traits = kissfft_utils::traits<T_Scalar, T_Complex>>
void kissfft< T_Scalar, T_Complex, T_traits >::kf_bfly4 ( cpx_type *  Fout,
const size_t  fstride,
const size_t  m 
)
inlineprivate

Definition at line 217 of file kissfft.h.

218  {
219  cpx_type scratch[7];
220  int negative_if_inverse = _inverse * -2 + 1;
221  for(size_t k = 0; k < m; ++k) {
222  //scratch[0] = Fout[k + m] * _traits.twiddle(k * fstride);
223  C_MUL(scratch[0], Fout[k + m], _traits.twiddle(k * fstride));
224  C_MUL(scratch[1], Fout[k + 2 * m], _traits.twiddle(k * fstride * 2));
225  C_MUL(scratch[2], Fout[k + 3 * m], _traits.twiddle(k * fstride * 3));
226  scratch[5] = Fout[k] - scratch[1];
227 
228  Fout[k] += scratch[1];
229  scratch[3] = scratch[0] + scratch[2];
230  scratch[4] = scratch[0] - scratch[2];
231  scratch[4] = cpx_type(scratch[4].imag() * negative_if_inverse, -scratch[4].real() * negative_if_inverse);
232 
233  Fout[k + 2 * m] = Fout[k] - scratch[3];
234  Fout[k] += scratch[3];
235  Fout[k + m] = scratch[5] + scratch[4];
236  Fout[k + 3 * m] = scratch[5] - scratch[4];
237  }
238  }
kissfft::cpx_type
traits_type::cpx_type cpx_type
Definition: kissfft.h:97
kissfft::C_MUL
void C_MUL(cpx_type &c, const cpx_type &a, const cpx_type &b)
Definition: kissfft.h:177
kissfft::_traits
traits_type _traits
Definition: kissfft.h:389
kissfft::_inverse
bool _inverse
Definition: kissfft.h:385

◆ kf_bfly5()

template<typename T_Scalar, typename T_Complex, typename T_traits = kissfft_utils::traits<T_Scalar, T_Complex>>
void kissfft< T_Scalar, T_Complex, T_traits >::kf_bfly5 ( cpx_type *  Fout,
const size_t  fstride,
const size_t  m 
)
inlineprivate

Definition at line 277 of file kissfft.h.

278  {
279  cpx_type* Fout0;
280  cpx_type* Fout1;
281  cpx_type* Fout2;
282  cpx_type* Fout3;
283  cpx_type* Fout4;
284  size_t u;
285  cpx_type scratch[13];
286  cpx_type* twiddles = &_twiddles[0];
287  cpx_type* tw;
288  cpx_type ya, yb;
289  ya = twiddles[fstride * m];
290  yb = twiddles[fstride * 2 * m];
291 
292  Fout0 = Fout;
293  Fout1 = Fout0 + m;
294  Fout2 = Fout0 + 2 * m;
295  Fout3 = Fout0 + 3 * m;
296  Fout4 = Fout0 + 4 * m;
297 
298  tw = twiddles;
299  for(u = 0; u < m; ++u) {
300  C_FIXDIV(*Fout0, 5);
301  C_FIXDIV(*Fout1, 5);
302  C_FIXDIV(*Fout2, 5);
303  C_FIXDIV(*Fout3, 5);
304  C_FIXDIV(*Fout4, 5);
305  scratch[0] = *Fout0;
306 
307  C_MUL(scratch[1], *Fout1, tw[u * fstride]);
308  C_MUL(scratch[2], *Fout2, tw[2 * u * fstride]);
309  C_MUL(scratch[3], *Fout3, tw[3 * u * fstride]);
310  C_MUL(scratch[4], *Fout4, tw[4 * u * fstride]);
311 
312  C_ADD(scratch[7], scratch[1], scratch[4]);
313  C_SUB(scratch[10], scratch[1], scratch[4]);
314  C_ADD(scratch[8], scratch[2], scratch[3]);
315  C_SUB(scratch[9], scratch[2], scratch[3]);
316 
317  C_ADDTO(*Fout0, scratch[7]);
318  C_ADDTO(*Fout0, scratch[8]);
319 
320  scratch[5] = scratch[0] + cpx_type(S_MUL(scratch[7].real(), ya.real()) + S_MUL(scratch[8].real(), yb.real()), S_MUL(scratch[7].imag(), ya.real())
321  + S_MUL(scratch[8].imag(), yb.real()));
322 
323  scratch[6] = cpx_type(S_MUL(scratch[10].imag(), ya.imag()) + S_MUL(scratch[9].imag(), yb.imag()), -S_MUL(scratch[10].real(), ya.imag()) - S_MUL(
324  scratch[9].real(), yb.imag()));
325 
326  C_SUB(*Fout1, scratch[5], scratch[6]);
327  C_ADD(*Fout4, scratch[5], scratch[6]);
328 
329  scratch[11] = scratch[0] + cpx_type(S_MUL(scratch[7].real(), yb.real()) + S_MUL(scratch[8].real(), ya.real()), S_MUL(scratch[7].imag(), yb.real())
330  + S_MUL(scratch[8].imag(), ya.real()));
331 
332  scratch[12] = cpx_type(-S_MUL(scratch[10].imag(), yb.imag()) + S_MUL(scratch[9].imag(), ya.imag()), S_MUL(scratch[10].real(), yb.imag()) - S_MUL(
333  scratch[9].real(), ya.imag()));
334 
335  C_ADD(*Fout2, scratch[11], scratch[12]);
336  C_SUB(*Fout3, scratch[11], scratch[12]);
337 
338  ++Fout0;
339  ++Fout1;
340  ++Fout2;
341  ++Fout3;
342  ++Fout4;
343  }
344  }
kissfft::C_SUB
void C_SUB(cpx_type &c, const cpx_type &a, const cpx_type &b)
Definition: kissfft.h:182
kissfft::cpx_type
traits_type::cpx_type cpx_type
Definition: kissfft.h:97
kissfft::S_MUL
scalar_type S_MUL(const scalar_type &a, const scalar_type &b)
Definition: kissfft.h:193
kissfft::_twiddles
std::vector< cpx_type > _twiddles
Definition: kissfft.h:386
kissfft::C_ADD
void C_ADD(cpx_type &c, const cpx_type &a, const cpx_type &b)
Definition: kissfft.h:173
kissfft::C_MUL
void C_MUL(cpx_type &c, const cpx_type &a, const cpx_type &b)
Definition: kissfft.h:177
kissfft::C_FIXDIV
void C_FIXDIV(cpx_type &, int)
Definition: kissfft.h:190
kissfft::C_ADDTO
void C_ADDTO(cpx_type &c, const cpx_type &a)
Definition: kissfft.h:186

◆ kf_bfly_generic()

template<typename T_Scalar, typename T_Complex, typename T_traits = kissfft_utils::traits<T_Scalar, T_Complex>>
void kissfft< T_Scalar, T_Complex, T_traits >::kf_bfly_generic ( cpx_type *  Fout,
const size_t  fstride,
int  m,
int  p 
)
inlineprivate

Definition at line 347 of file kissfft.h.

348  {
349  int u;
350  int k;
351  int q1;
352  int q;
353  cpx_type* twiddles = &_twiddles[0];
354  cpx_type t;
355  int Norig = _nfft;
356  cpx_type* scratchbuf = new cpx_type[p];
357 
358  for(u = 0; u < m; ++u) {
359  k = u;
360  for(q1 = 0; q1 < p; ++q1) {
361  scratchbuf[q1] = Fout[k];
362  C_FIXDIV(scratchbuf[q1], p);
363  k += m;
364  }
365 
366  k = u;
367  for(q1 = 0; q1 < p; ++q1) {
368  int twidx = 0;
369  Fout[k] = scratchbuf[0];
370  for(q = 1; q < p; ++q) {
371  twidx += fstride * k;
372  if(twidx >= Norig)
373  twidx -= Norig;
374  C_MUL(t, scratchbuf[q], twiddles[twidx]);
375  C_ADDTO(Fout[k], t);
376  }
377  k += m;
378  }
379  }
380 
381  delete[] scratchbuf;
382  }
kissfft::cpx_type
traits_type::cpx_type cpx_type
Definition: kissfft.h:97
kissfft::_nfft
int _nfft
Definition: kissfft.h:384
kissfft::_twiddles
std::vector< cpx_type > _twiddles
Definition: kissfft.h:386
kissfft::C_MUL
void C_MUL(cpx_type &c, const cpx_type &a, const cpx_type &b)
Definition: kissfft.h:177
kissfft::C_FIXDIV
void C_FIXDIV(cpx_type &, int)
Definition: kissfft.h:190
kissfft::C_ADDTO
void C_ADDTO(cpx_type &c, const cpx_type &a)
Definition: kissfft.h:186

◆ kf_work()

template<typename T_Scalar, typename T_Complex, typename T_traits = kissfft_utils::traits<T_Scalar, T_Complex>>
void kissfft< T_Scalar, T_Complex, T_traits >::kf_work ( int  stage,
cpx_type *  Fout,
const cpx_type *  f,
size_t  fstride,
size_t  in_stride 
)
inlineprivate

Definition at line 127 of file kissfft.h.

128  {
129  int p = _stageRadix[stage];
130  int m = _stageRemainder[stage];
131  cpx_type * Fout_beg = Fout;
132  cpx_type * Fout_end = Fout + p * m;
133 
134  if(m == 1) {
135  do {
136  *Fout = *f;
137  f += fstride * in_stride;
138  } while(++Fout != Fout_end);
139  } else {
140  do {
141  // recursive call:
142  // DFT of size m*p performed by doing
143  // p instances of smaller DFTs of size m,
144  // each one takes a decimated version of the input
145  kf_work(stage + 1, Fout, f, fstride * p, in_stride);
146  f += fstride * in_stride;
147  } while((Fout += m) != Fout_end);
148  }
149 
150  Fout = Fout_beg;
151 
152  // recombine the p smaller DFTs
153  switch(p) {
154  case 2:
155  kf_bfly2(Fout, fstride, m);
156  break;
157  case 3:
158  kf_bfly3(Fout, fstride, m);
159  break;
160  case 4:
161  kf_bfly4(Fout, fstride, m);
162  break;
163  case 5:
164  kf_bfly5(Fout, fstride, m);
165  break;
166  default:
167  kf_bfly_generic(Fout, fstride, m, p);
168  break;
169  }
170  }
kissfft::cpx_type
traits_type::cpx_type cpx_type
Definition: kissfft.h:97
kissfft::kf_bfly3
void kf_bfly3(cpx_type *Fout, const size_t fstride, const size_t m)
Definition: kissfft.h:240
kissfft::_stageRadix
std::vector< int > _stageRadix
Definition: kissfft.h:387
kissfft::kf_bfly_generic
void kf_bfly_generic(cpx_type *Fout, const size_t fstride, int m, int p)
Definition: kissfft.h:347
kissfft::_stageRemainder
std::vector< int > _stageRemainder
Definition: kissfft.h:388
kissfft::kf_bfly5
void kf_bfly5(cpx_type *Fout, const size_t fstride, const size_t m)
Definition: kissfft.h:277
kissfft::kf_bfly4
void kf_bfly4(cpx_type *Fout, const size_t fstride, const size_t m)
Definition: kissfft.h:217
kissfft::kf_bfly2
void kf_bfly2(cpx_type *Fout, const size_t fstride, int m)
Definition: kissfft.h:206
kissfft::kf_work
void kf_work(int stage, cpx_type *Fout, const cpx_type *f, size_t fstride, size_t in_stride)
Definition: kissfft.h:127

◆ S_MUL()

template<typename T_Scalar, typename T_Complex, typename T_traits = kissfft_utils::traits<T_Scalar, T_Complex>>
scalar_type kissfft< T_Scalar, T_Complex, T_traits >::S_MUL ( const scalar_type &  a,
const scalar_type &  b 
)
inlineprivate

Definition at line 193 of file kissfft.h.

194  {
195  return a * b;
196  }

◆ transform()

template<typename T_Scalar, typename T_Complex, typename T_traits = kissfft_utils::traits<T_Scalar, T_Complex>>
void kissfft< T_Scalar, T_Complex, T_traits >::transform ( const cpx_type *  src,
cpx_type *  dst 
)
inline

Definition at line 121 of file kissfft.h.

Referenced by KissEngine::transform().

122  {
123  kf_work(0, dst, src, 1, 1);
124  }
kissfft::kf_work
void kf_work(int stage, cpx_type *Fout, const cpx_type *f, size_t fstride, size_t in_stride)
Definition: kissfft.h:127
+ Here is the caller graph for this function:

Member Data Documentation

◆ _inverse

template<typename T_Scalar, typename T_Complex, typename T_traits = kissfft_utils::traits<T_Scalar, T_Complex>>
bool kissfft< T_Scalar, T_Complex, T_traits >::_inverse
private

Definition at line 385 of file kissfft.h.

◆ _nfft

template<typename T_Scalar, typename T_Complex, typename T_traits = kissfft_utils::traits<T_Scalar, T_Complex>>
int kissfft< T_Scalar, T_Complex, T_traits >::_nfft
private

Definition at line 384 of file kissfft.h.

◆ _stageRadix

template<typename T_Scalar, typename T_Complex, typename T_traits = kissfft_utils::traits<T_Scalar, T_Complex>>
std::vector<int> kissfft< T_Scalar, T_Complex, T_traits >::_stageRadix
private

Definition at line 387 of file kissfft.h.

◆ _stageRemainder

template<typename T_Scalar, typename T_Complex, typename T_traits = kissfft_utils::traits<T_Scalar, T_Complex>>
std::vector<int> kissfft< T_Scalar, T_Complex, T_traits >::_stageRemainder
private

Definition at line 388 of file kissfft.h.

◆ _traits

template<typename T_Scalar, typename T_Complex, typename T_traits = kissfft_utils::traits<T_Scalar, T_Complex>>
traits_type kissfft< T_Scalar, T_Complex, T_traits >::_traits
private

Definition at line 389 of file kissfft.h.

◆ _twiddles

template<typename T_Scalar, typename T_Complex, typename T_traits = kissfft_utils::traits<T_Scalar, T_Complex>>
std::vector<cpx_type> kissfft< T_Scalar, T_Complex, T_traits >::_twiddles
private

Definition at line 386 of file kissfft.h.

The documentation for this class was generated from the following file:
Generated on Fri Aug 2 2019 17:56:41 for SDRAngel by   doxygen 1.8.13